JitIL is no longer a separate .exe/binary - it's now a simple option, Dolphin.exe now contains both cores.

Advantages:
* Less confusion for users
* No need to build twice to make sure you didn't break something
* Easier to switch between the cores for testing

Disadvantages:
* None, as far as I can tell :) Maybe some extra code complexity, but not much.

Also break some include chains that caused <windows.h> to get included into everything, slowing down the build on Windows. There's more to do here though, there's still a lot of files that get it included that don't need it at all.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4891 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
hrydgard 2010-01-19 19:28:27 +00:00
parent 657ba22f54
commit 576990c5a3
82 changed files with 1365 additions and 1953 deletions

View File

@ -535,6 +535,10 @@
RelativePath=".\Src\ConsoleListener.cpp"
>
</File>
<File
RelativePath=".\Src\ConsoleListener.h"
>
</File>
<File
RelativePath=".\Src\Log.h"
>

View File

@ -3,6 +3,30 @@
#include "CDUtils.h"
#include "Common.h"
#ifdef _WIN32
#include <windows.h>
#define PATH_MAX MAX_PATH
#elif __APPLE__
#include <paths.h>
#include <Carbon/Carbon.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/storage/IOCDMedia.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/IOBSD.h>
#elif __linux__
#include <mntent.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <linux/cdrom.h>
#endif // WIN32
// Follow symlinks until we have the real device file (idea taken from libunieject).
void cdio_follow_symlink(const char * src, char * dst) {
#ifndef _WIN32

View File

@ -5,30 +5,6 @@
#include <string.h>
#include <stdio.h>
#ifdef _WIN32
#include <windows.h>
#define PATH_MAX MAX_PATH
#elif __APPLE__
#include <paths.h>
#include <Carbon/Carbon.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/storage/IOCDMedia.h>
#include <IOKit/storage/IOMedia.h>
#include <IOKit/IOBSD.h>
#elif __linux__
#include <mntent.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <linux/cdrom.h>
#endif // WIN32
// Returns a pointer to an array of strings with the device names
char **cdio_get_devices();

View File

@ -18,6 +18,9 @@
#ifndef _COMMON_H_
#define _COMMON_H_
// DO NOT EVER INCLUDE <windows.h> directly _or indirectly_ from this file
// since it slows down the build a lot.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

View File

@ -28,6 +28,7 @@
#include "Common.h"
#include "LogManager.h" // Common
#include "ConsoleListener.h" // Common
ConsoleListener::ConsoleListener()
{

View File

@ -0,0 +1,55 @@
// 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.
// 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 _CONSOLELISTENER_H
#define _CONSOLELISTENER_H
#include "LogManager.h"
#ifdef _WIN32
#include <windows.h>
#endif
class ConsoleListener : public LogListener
{
public:
ConsoleListener();
~ConsoleListener();
void Open(bool Hidden = false, int Width = 100, int Height = 100, const char * Name = "Console");
void UpdateHandle();
void Close();
bool IsOpen();
void LetterSpace(int Width, int Height);
void BufferWidthHeight(int BufferWidth, int BufferHeight, int ScreenWidth, int ScreenHeight, bool BufferFirst);
void PixelSpace(int Left, int Top, int Width, int Height, bool);
#ifdef _WIN32
COORD GetCoordinates(int BytesRead, int BufferWidth);
#endif
void Log(LogTypes::LOG_LEVELS, const char *Text);
void ClearScreen(bool Cursor = true);
const char *getName() const { return "Console"; }
private:
#ifdef _WIN32
HWND GetHwnd(void);
HANDLE hConsole;
#endif
};
#endif // _CONSOLELISTENER_H

View File

@ -69,7 +69,7 @@ int LinearDiskCache::OpenAndRead(const char *filename, LinearDiskCacheReader *re
fclose(file_);
unlink(filename);
PanicAlert("LinearDiskCache file header broken.");
// PanicAlert("LinearDiskCache file header broken.");
file_ = fopen(filename, "wb");
WriteHeader();
@ -86,8 +86,8 @@ int LinearDiskCache::OpenAndRead(const char *filename, LinearDiskCacheReader *re
break;
}
if (key_size <= 0 || value_size < 0 || key_size_size != 4 || value_size_size != 4) {
PanicAlert("Disk cache file %s corrupted/truncated! ks: %i vs %i kss %i vss %i", filename,
key_size, value_size, key_size_size, value_size_size);
// PanicAlert("Disk cache file %s corrupted/truncated! ks: %i vs %i kss %i vss %i", filename,
// key_size, value_size, key_size_size, value_size_size);
file_corrupt = true;
break;
}
@ -96,8 +96,8 @@ int LinearDiskCache::OpenAndRead(const char *filename, LinearDiskCacheReader *re
int actual_key_size = (int)fread(key, 1, key_size, file_);
int actual_value_size = (int)fread(value, 1, value_size, file_);
if (actual_key_size != key_size || actual_value_size != value_size) {
PanicAlert("Disk cache file %s corrupted/truncated! ks: %i actual ks: %i vs: %i actual vs: %i", filename,
key_size, actual_key_size, value_size, actual_value_size);
// PanicAlert("Disk cache file %s corrupted/truncated! ks: %i actual ks: %i vs: %i actual vs: %i", filename,
// key_size, actual_key_size, value_size, actual_value_size);
file_corrupt = true;
} else {
reader->Read(key, key_size, value, value_size);

View File

@ -16,7 +16,10 @@
// http://code.google.com/p/dolphin-emu/
#include "LogManager.h"
#include "ConsoleListener.h"
#include "Timer.h"
#include "Thread.h"
void GenericLog(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type,
const char *file, int line, const char* fmt, ...)
{
@ -28,7 +31,9 @@ void GenericLog(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type,
LogManager *LogManager::m_logManager = NULL;
LogManager::LogManager() : logMutex(1) {
LogManager::LogManager() {
logMutex = new Common::CriticalSection(1);
// create log files
m_Log[LogTypes::MASTER_LOG] = new LogContainer("*", "Master Log");
m_Log[LogTypes::BOOT] = new LogContainer("BOOT", "Boot");
@ -92,6 +97,7 @@ LogManager::~LogManager() {
}
delete m_fileLog;
delete m_consoleLog;
delete logMutex;
}
void LogManager::Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type,
@ -113,15 +119,15 @@ void LogManager::Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type,
file, line, level_to_char[(int)level],
log->getShortName(), temp);
logMutex.Enter();
logMutex->Enter();
log->trigger(level, msg);
logMutex.Leave();
logMutex->Leave();
}
void LogManager::removeListener(LogTypes::LOG_TYPE type, LogListener *listener) {
logMutex.Enter();
logMutex->Enter();
m_Log[type]->removeListener(listener);
logMutex.Leave();
logMutex->Leave();
}
LogContainer::LogContainer(const char* shortName, const char* fullName, bool enable)

View File

@ -19,11 +19,8 @@
#define _LOGMANAGER_H_
#include "Log.h"
#include "Thread.h"
#include "StringUtil.h"
#ifdef _WIN32
#include <windows.h>
#endif
#include <vector>
#include <string.h>
#include <stdio.h>
@ -67,34 +64,6 @@ private:
bool m_enable;
};
class ConsoleListener : public LogListener
{
public:
ConsoleListener();
~ConsoleListener();
void Open(bool Hidden = false, int Width = 100, int Height = 100, const char * Name = "Console");
void UpdateHandle();
void Close();
bool IsOpen();
void LetterSpace(int Width, int Height);
void BufferWidthHeight(int BufferWidth, int BufferHeight, int ScreenWidth, int ScreenHeight, bool BufferFirst);
void PixelSpace(int Left, int Top, int Width, int Height, bool);
#ifdef _WIN32
COORD GetCoordinates(int BytesRead, int BufferWidth);
#endif
void Log(LogTypes::LOG_LEVELS, const char *Text);
void ClearScreen(bool Cursor = true);
const char *getName() const { return "Console"; }
private:
#ifdef _WIN32
HWND GetHwnd(void);
HANDLE hConsole;
#endif
};
class LogContainer {
public:
LogContainer(const char* shortName, const char* fullName, bool enable = false);
@ -130,16 +99,26 @@ private:
std::vector<LogListener *> listeners;
};
class ConsoleListener;
// Avoid <windows.h> include through Thread.h
namespace Common {
class CriticalSection;
}
class LogManager
{
private:
LogContainer* m_Log[LogTypes::NUMBER_OF_LOGS];
Common::CriticalSection logMutex;
Common::CriticalSection *logMutex;
FileLogListener *m_fileLog;
ConsoleListener *m_consoleLog;
static LogManager *m_logManager; // Singleton. Ugh.
public:
LogManager();
~LogManager();
static u32 GetMaxLevel() { return MAX_LOGLEVEL; }
void Log(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type,
@ -192,9 +171,6 @@ public:
static void SetInstance(LogManager *logManager) {
m_logManager = logManager;
}
LogManager();
~LogManager();
};
#endif // _LOGMANAGER_H_

View File

@ -18,7 +18,7 @@
#ifndef _MEMORYUTIL_H
#define _MEMORYUTIL_H
#include <iostream>
#include <string>
void* AllocateExecutableMemory(size_t size, bool low = true);
void* AllocateMemoryPages(size_t size);

View File

@ -18,6 +18,9 @@
#ifndef __SYSCONF_MANAGER_h__
#define __SYSCONF_MANAGER_h__
#include <string>
#include <vector>
// This class is meant to edit the values in a given Wii SYSCONF file
// It currently does not add/remove/rearrange sections,
// instead only modifies exiting sections' data

File diff suppressed because it is too large Load Diff

View File

@ -22,6 +22,10 @@
#include "ARDecrypt.h"
#include <algorithm>
#ifdef _WIN32
#include <windows.h>
#endif
namespace ActionReplay
{

View File

@ -17,10 +17,6 @@
#ifndef _ARDECRYPT_H_
#define _ARDECRYPT_H_
#ifdef _WIN32
#include <windows.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

View File

@ -104,7 +104,7 @@ void SConfig::SaveSettings()
// Core
ini.Set("Core", "HLE_BS2", m_LocalCoreStartupParameter.bHLE_BS2);
ini.Set("Core", "UseDynarec", m_LocalCoreStartupParameter.bUseJIT);
ini.Set("Core", "CPUCore", m_LocalCoreStartupParameter.iCPUCore);
ini.Set("Core", "CPUThread", m_LocalCoreStartupParameter.bCPUThread);
ini.Set("Core", "DSPThread", m_LocalCoreStartupParameter.bDSPThread);
ini.Set("Core", "SkipIdle", m_LocalCoreStartupParameter.bSkipIdle);
@ -224,7 +224,7 @@ void SConfig::LoadSettings()
// Core
ini.Get("Core", "HLE_BS2", &m_LocalCoreStartupParameter.bHLE_BS2, true);
ini.Get("Core", "UseDynarec", &m_LocalCoreStartupParameter.bUseJIT, true);
ini.Get("Core", "CPUCore", &m_LocalCoreStartupParameter.iCPUCore, 1);
ini.Get("Core", "DSPThread", &m_LocalCoreStartupParameter.bDSPThread, true);
ini.Get("Core", "CPUThread", &m_LocalCoreStartupParameter.bCPUThread, true);
ini.Get("Core", "SkipIdle", &m_LocalCoreStartupParameter.bSkipIdle, true);

View File

@ -25,7 +25,7 @@
#include "PowerPC/PPCTables.h"
#include "CoreTiming.h"
#include "Core.h"
#include "PowerPC/Jit64/Jit.h"
#include "PowerPC/JitCommon/JitBase.h"
#include "PowerPC/PPCSymbolDB.h"
#include "PowerPCDisasm.h"
#include "Console.h"

View File

@ -47,6 +47,7 @@
#include "HW/SystemTimers.h"
#include "PowerPC/PowerPC.h"
#include "PowerPC/JitCommon/JitBase.h"
#include "PluginManager.h"
#include "ConfigManager.h"
@ -387,7 +388,7 @@ THREAD_RETURN EmuThread(void *pArg)
g_pUpdateFPSDisplay(("Loading " + _CoreParameter.m_strFilename).c_str());
// Setup our core, but can't use dynarec if we are compare server
if (_CoreParameter.bUseJIT && (!_CoreParameter.bRunCompareServer || _CoreParameter.bRunCompareClient))
if (_CoreParameter.iCPUCore && (!_CoreParameter.bRunCompareServer || _CoreParameter.bRunCompareClient))
PowerPC::SetMode(PowerPC::MODE_JIT);
else
PowerPC::SetMode(PowerPC::MODE_INTERPRETER);
@ -592,18 +593,10 @@ void VideoThrottle()
// Settings are shown the same for both extended and summary info
std::string SSettings = StringFromFormat("%s %s",
#if defined(JITTEST) && JITTEST
#ifdef _M_IX86
_CoreParameter.bUseJIT ? "JIT32IL" : "Int32",
#else
_CoreParameter.bUseJIT ? "JIT64IL" : "Int64",
#endif
#ifdef _M_IX86
_CoreParameter.iCPUCore ? jit->GetName() : "Int32",
#else
#ifdef _M_IX86
_CoreParameter.bUseJIT ? "JIT32" : "Int32",
#else
_CoreParameter.bUseJIT ? "JIT64" : "Int64",
#endif
_CoreParameter.iCPUCore ? jit->GetName() : "Int64",
#endif
_CoreParameter.bCPUThread ? "DC" : "SC");

View File

@ -37,7 +37,7 @@ SCoreStartupParameter::SCoreStartupParameter()
void SCoreStartupParameter::LoadDefaults()
{
bEnableDebugging = false;
bUseJIT = false;
iCPUCore = 1;
bCPUThread = false;
bSkipIdle = false;
bRunCompareServer = false;

View File

@ -18,10 +18,6 @@
#ifndef _COREPARAMETER_H
#define _COREPARAMETER_H
#ifdef _WIN32
#include <windows.h>
#endif
#include "IniFile.h"
#include <string>
@ -30,18 +26,22 @@
struct SCoreStartupParameter
{
#ifdef _WIN32
HINSTANCE hInstance;
#endif
void * hInstance; // HINSTANCE but we don't want to include <windows.h>
// Windows/GUI related
void* hMainWindow;
// Settings
bool bEnableDebugging; bool bAutomaticStart; bool bBootToPause;
bool bUseJIT;
bool bEnableDebugging;
bool bAutomaticStart;
bool bBootToPause;
// JIT
// 0 = Interpreter
// 1 = Jit
// 2 = JitIL
int iCPUCore;
// JIT (shared between JIT and JITIL)
bool bJITUnlimitedCache, bJITBlockLinking;
bool bJITOff;
bool bJITLoadStoreOff, bJITLoadStorelXzOff, bJITLoadStorelwzOff, bJITLoadStorelbzxOff;

View File

@ -25,7 +25,7 @@
#include "../HW/DSP.h"
#include "../HW/Memmap.h"
#include "../PowerPC/PowerPC.h"
#include "../PowerPC/Jit64/Jit.h"
#include "../PowerPC/JitCommon/JitBase.h"
#include "../PowerPC/PPCSymbolDB.h"
void PPCDebugInterface::disasm(unsigned int address, char *dest, int max_size)
@ -114,13 +114,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() {}

View File

@ -30,10 +30,10 @@ namespace
static Common::Event *m_SyncEvent;
}
void CCPU::Init()
void CCPU::Init(int cpu_core)
{
m_StepEvent.Init();
PowerPC::Init();
PowerPC::Init(cpu_core);
m_SyncEvent = 0;
}

View File

@ -27,7 +27,7 @@ class CCPU
{
public:
// init
static void Init();
static void Init(int cpu_core);
// shutdown
static void Shutdown();

View File

@ -76,7 +76,7 @@ void STACKALIGN CheckGatherPipe()
// move back the spill bytes
m_gatherPipeCount -= GATHER_PIPE_SIZE;
// HyperIris: dunno why, but I use memcpy
// HyperIris: dunno why, but I use memcpy. TODO: See if a custom copy can be faster, like 4x MOVAPD
memcpy(m_gatherPipe, m_gatherPipe + GATHER_PIPE_SIZE, m_gatherPipeCount);
// increase the CPUWritePointer

View File

@ -58,7 +58,7 @@ namespace HW
DVDInterface::Init();
GPFifo::Init();
ExpansionInterface::Init();
CCPU::Init();
CCPU::Init(SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore);
SystemTimers::Init();
if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii)
{

View File

@ -29,7 +29,7 @@ may be redirected here (for example to Read_U32()).
#include "Memmap.h"
#include "../Core.h"
#include "../PowerPC/PowerPC.h"
#include "../PowerPC/Jit64/Jit.h"
#include "../PowerPC/JitCommon/JitBase.h"
#include "../HLE/HLE.h"
#include "CPU.h"
#include "ProcessorInterface.h"
@ -81,6 +81,7 @@ u8 *m_pRAM;
u8 *m_pL1Cache;
u8 *m_pEXRAM;
u8 *m_pFakeVMEM;
u8 *m_pEFB;
// 64-bit: Pointers to high-mem mirrors
// 32-bit: Same as above
@ -330,7 +331,9 @@ static const MemoryView views[] =
// Don't map any memory for the EFB. We want all access to this area to go
// through the hardware access handlers.
#ifndef _M_X64
// {&m_pEFB, &m_pVirtualEFB, 0xC8000000, EFB_SIZE, 0},
#endif
{&m_pL1Cache, &m_pVirtualL1Cache, 0xE0000000, L1_CACHE_SIZE, 0},
{&m_pFakeVMEM, &m_pVirtualFakeVMEM, 0x7E000000, FAKEVMEM_SIZE, MV_FAKE_VMEM},
@ -427,17 +430,17 @@ u32 Read_Opcode_JIT(const u32 _Address)
u32 addr;
if (_Address & JIT_ICACHE_VMEM_BIT)
{
iCache = jit.GetBlockCache()->GetICacheVMEM();
iCache = jit->GetBlockCache()->GetICacheVMEM();
addr = _Address & JIT_ICACHE_MASK;
}
else if (_Address & JIT_ICACHE_EXRAM_BIT)
{
iCache = jit.GetBlockCache()->GetICacheEx();
iCache = jit->GetBlockCache()->GetICacheEx();
addr = _Address & JIT_ICACHEEX_MASK;
}
else
{
iCache = jit.GetBlockCache()->GetICache();
iCache = jit->GetBlockCache()->GetICache();
addr = _Address & JIT_ICACHE_MASK;
}
u32 inst = *(u32*)(iCache + addr);
@ -455,7 +458,7 @@ u32 Read_Opcode_JIT(const u32 _Address)
#endif
if ((inst & 0xfc000000) == 0)
{
inst = jit.GetBlockCache()->GetOriginalFirstOp(inst);
inst = jit->GetBlockCache()->GetOriginalFirstOp(inst);
}
// if a crash occured after that message
@ -481,17 +484,17 @@ u32 Read_Opcode_JIT_LC(const u32 _Address)
u32 addr;
if (_Address & JIT_ICACHE_VMEM_BIT)
{
iCache = jit.GetBlockCache()->GetICacheVMEM();
iCache = jit->GetBlockCache()->GetICacheVMEM();
addr = _Address & JIT_ICACHE_MASK;
}
else if (_Address & JIT_ICACHE_EXRAM_BIT)
{
iCache = jit.GetBlockCache()->GetICacheEx();
iCache = jit->GetBlockCache()->GetICacheEx();
addr = _Address & JIT_ICACHEEX_MASK;
}
else
{
iCache = jit.GetBlockCache()->GetICache();
iCache = jit->GetBlockCache()->GetICache();
addr = _Address & JIT_ICACHE_MASK;
}
u32 inst = *(u32*)(iCache + addr);
@ -504,7 +507,7 @@ u32 Read_Opcode_JIT_LC(const u32 _Address)
#endif
if ((inst & 0xfc000000) == 0)
{
inst = jit.GetBlockCache()->GetOriginalFirstOp(inst);
inst = jit->GetBlockCache()->GetOriginalFirstOp(inst);
}
return inst;
}
@ -516,14 +519,14 @@ void Write_Opcode_JIT(const u32 _Address, const u32 _Value)
#ifdef JIT_UNLIMITED_ICACHE
if (_Address & JIT_ICACHE_VMEM_BIT)
{
*(u32*)(jit.GetBlockCache()->GetICacheVMEM() + (_Address & JIT_ICACHE_MASK)) = Common::swap32(_Value);
*(u32*)(jit->GetBlockCache()->GetICacheVMEM() + (_Address & JIT_ICACHE_MASK)) = Common::swap32(_Value);
}
else if (_Address & JIT_ICACHE_EXRAM_BIT)
{
*(u32*)(jit.GetBlockCache()->GetICacheEx() + (_Address & JIT_ICACHEEX_MASK)) = Common::swap32(_Value);
*(u32*)(jit->GetBlockCache()->GetICacheEx() + (_Address & JIT_ICACHEEX_MASK)) = Common::swap32(_Value);
}
else
*(u32*)(jit.GetBlockCache()->GetICache() + (_Address & JIT_ICACHE_MASK)) = Common::swap32(_Value);
*(u32*)(jit->GetBlockCache()->GetICache() + (_Address & JIT_ICACHE_MASK)) = Common::swap32(_Value);
#else
Memory::WriteUnchecked_U32(_Value, _Address);
#endif

View File

@ -20,7 +20,6 @@
#include <string>
#include <queue>
#include "../HW/Memmap.h"
#include "../HW/CPU.h"
class PointerWrap;

View File

@ -20,6 +20,9 @@
#include "WII_IPC_HLE_Device_usb.h"
#include "WII_IPC_HLE_Device_usb_kbd.h"
#ifdef _WIN32
#include <windows.h>
#endif
CWII_IPC_HLE_Device_usb_kbd::CWII_IPC_HLE_Device_usb_kbd(u32 _DeviceID, const std::string& _rDeviceName)
: IWII_IPC_HLE_Device(_DeviceID, _rDeviceName)

View File

@ -33,6 +33,9 @@
#define CREG_EIP(ctx) (*(ctx))->__ss.__eip
#endif
#else
#include <windows.h>
#endif
#include <vector>
@ -41,7 +44,7 @@
#include "MemTools.h"
#include "HW/Memmap.h"
#include "PowerPC/PowerPC.h"
#include "PowerPC/Jit64/Jit.h"
#include "PowerPC/JitCommon/JitBase.h"
#include "x64Analyzer.h"
namespace EMM
@ -65,7 +68,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 +98,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 +193,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 +220,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;

View File

@ -23,7 +23,7 @@
#include "Interpreter.h"
#include "../../Core.h"
#include "../Jit64/Jit.h"
#include "../JitCommon/JitBase.h"
#include "../JitCommon/JitCache.h"
#include "Interpreter_FPUtils.h"
@ -374,7 +374,7 @@ void icbi(UGeckoInstruction _inst)
{
u32 address = Helper_Get_EA_X(_inst);
PowerPC::ppcState.iCache.Invalidate(address);
jit.GetBlockCache()->InvalidateICache(address);
jit->GetBlockCache()->InvalidateICache(address);
}
void lbzux(UGeckoInstruction _inst)

View File

@ -17,6 +17,11 @@
#include <map>
// for the PROFILER stuff
#ifdef _WIN32
#include <windows.h>
#endif
#include "Common.h"
#include "x64Emitter.h"
#include "ABI.h"
@ -35,17 +40,11 @@
#include "Jit.h"
#include "JitAsm.h"
#include "JitRegCache.h"
#include "../JitCommon/Jit_Tables.h"
#if defined JITTEST && JITTEST
#error Jit64 cannot have JITTEST define
#endif
#include "Jit64_Tables.h"
using namespace Gen;
using namespace PowerPC;
extern int blocksExecuted;
// Dolphin's PowerPC->x86 JIT dynamic recompiler
// (Nearly) all code by ector (hrydgard)
// Features:
@ -110,7 +109,7 @@ extern int blocksExecuted;
/*
* Assume SP is in main RAM (in Wii mode too?) - partly done
* Assume all floating point loads and double precision loads+stores are to/from main ram
(single precision can be used in write gather pipe, specialized fast check added)
(single precision stores can be used in write gather pipe, specialized fast check added)
* AMD only - use movaps instead of movapd when loading ps from memory?
* HLE functions like floorf, sin, memcpy, etc - they can be much faster
* ABI optimizations - drop F0-F13 on blr, for example. Watch out for context switching.
@ -161,42 +160,15 @@ ps_adds1
*/
//#define NAN_CHECK
static void CheckForNans()
{
static bool lastNan[32];
for (int i = 0; i < 32; i++) {
double v = rPS0(i);
if (v != v) {
if (!lastNan[i]) {
lastNan[i] = true;
PanicAlert("PC = %08x Got NAN in R%i", PC, i);
}
} else {
lastNan[i] = false;
}
}
}
Jit64 jit;
int CODE_SIZE = 1024*1024*16;
static int CODE_SIZE = 1024*1024*16;
namespace CPUCompare
{
extern u32 m_BlockStart;
}
void Jit(u32 em_address)
{
jit.Jit(em_address);
}
void Jit64::Init()
{
asm_routines.compareEnabled = ::Core::g_CoreStartupParameter.bRunCompareClient;
jo.optimizeStack = true;
/* This will enable block linking in JitBlockCache::FinalizeBlock(), it gives faster execution but may not
be as stable as the alternative (to not link the blocks). However, I have not heard about any good examples
@ -274,7 +246,6 @@ void Jit64::WriteCallInterpreter(UGeckoInstruction inst)
void Jit64::unknown_instruction(UGeckoInstruction inst)
{
// CCPU::Break();
PanicAlert("unknown_instruction %08x - Fix me ;)", inst.hex);
}
@ -310,7 +281,7 @@ static const bool ImHereDebug = false;
static const bool ImHereLog = false;
static std::map<u32, int> been_here;
void ImHere()
static void ImHere()
{
static FILE *f = 0;
if (ImHereLog) {
@ -338,13 +309,6 @@ void Jit64::Cleanup()
{
if (jo.optimizeGatherPipe && js.fifoBytesThisBlock > 0)
ABI_CallFunction((void *)&GPFifo::CheckGatherPipe);
#ifdef NAN_CHECK
#ifdef _WIN32
if (GetAsyncKeyState(VK_LSHIFT))
ABI_CallFunction(thunks.ProtectFunction((void *)&CheckForNans, 0));
#endif
#endif
}
void Jit64::WriteExit(u32 destination, int exit_num)
@ -490,9 +454,9 @@ const u8* Jit64::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buf, JitBloc
if (Profiler::g_ProfileBlocks) {
ADD(32, M(&b->runCount), Imm8(1));
#ifdef _WIN32
b->ticCounter.QuadPart = 0;
b->ticStart.QuadPart = 0;
b->ticStop.QuadPart = 0;
b->ticCounter = 0;
b->ticStart = 0;
b->ticStop = 0;
#else
//TODO
#endif
@ -555,7 +519,7 @@ const u8* Jit64::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buf, JitBloc
}
if (!ops[i].skip)
JitTables::CompileInstruction(ops[i].inst);
Jit64Tables::CompileInstruction(ops[i].inst);
gpr.SanityCheck();
fpr.SanityCheck();

View File

@ -31,14 +31,8 @@
// ----------
#define JIT_OFF_OPTIONS // Compile with JIT off options
// Include
// ----------
#if JITTEST
#include "../Jit64IL/Jit.h"
#else
#ifndef _JIT_H
#define _JIT_H
#ifndef _JIT64_H
#define _JIT64_H
#include "../PPCAnalyst.h"
#include "../JitCommon/JitCache.h"
@ -46,32 +40,9 @@
#include "JitRegCache.h"
#include "x64Emitter.h"
#include "x64Analyzer.h"
#ifdef _WIN32
#include <windows.h>
#endif
// Declarations and definitions
// ----------
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
#include "../JitCommon/JitBackpatch.h"
#include "../JitCommon/JitBase.h"
#include "JitAsm.h"
// Use these to control the instruction selection
// #define INSTRUCTION_START Default(inst); return;
@ -83,18 +54,7 @@ void Jit(u32 em_address);
Core::g_CoreStartupParameter.bJIT##type##Off) \
{Default(inst); return;}
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 EmuCodeBlock
class Jit64 : public JitBase
{
private:
struct JitState
@ -121,35 +81,19 @@ private:
JitBlock *curBlock;
};
struct JitOptions
{
bool optimizeStack;
bool assumeFPLoadFromMem;
bool enableBlocklink;
bool fpAccurateFcmp;
bool enableFastMem;
bool optimizeGatherPipe;
bool fastInterrupts;
bool accurateSinglePrecision;
};
JitBlockCache blocks;
TrampolineCache trampolines;
GPRRegCache gpr;
FPURegCache fpr;
// 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;
Jit64AsmRoutineManager asm_routines;
public:
Jit64() : code_buffer(32000) {}
~Jit64() {}
JitState js;
JitOptions jo;
// Initialization, etc
void Init();
void Shutdown();
@ -165,15 +109,25 @@ public:
void ClearCache();
const u8 *GetDispatcher() {
return asm_routines.dispatcher; // asm_routines.dispatcher
}
const CommonAsmRoutines *GetAsmRoutines() {
return &asm_routines;
}
const char *GetName() {
#ifdef _M_X64
return "JIT64";
#else
return "JIT32";
#endif
}
// Run!
void Run();
void SingleStep();
const u8 *BackPatch(u8 *codePtr, int accessType, u32 em_address, CONTEXT *ctx);
#define JIT_OPCODE 0
// Utilities for use by opcodes
void WriteExit(u32 destination, int exit_num);
@ -296,7 +250,6 @@ public:
void icbi(UGeckoInstruction inst);
};
extern Jit64 jit;
void ProfiledReJit();
#endif // _JIT_H
#endif // JITTEST
#endif // _JIT64_H

View File

@ -15,25 +15,24 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "Jit_Tables.h"
#include "Jit.h"
#include "Jit64_Tables.h"
// Should be moved in to the Jit class
typedef void (Jit64::*_Instruction) (UGeckoInstruction instCode);
_Instruction dynaOpTable[64];
_Instruction dynaOpTable4[1024];
_Instruction dynaOpTable19[1024];
_Instruction dynaOpTable31[1024];
_Instruction dynaOpTable59[32];
_Instruction dynaOpTable63[1024];
static _Instruction dynaOpTable[64];
static _Instruction dynaOpTable4[1024];
static _Instruction dynaOpTable19[1024];
static _Instruction dynaOpTable31[1024];
static _Instruction dynaOpTable59[32];
static _Instruction dynaOpTable63[1024];
void Jit64::DynaRunTable4(UGeckoInstruction _inst) {(this->*dynaOpTable4 [_inst.SUBOP10])(_inst);}
void Jit64::DynaRunTable19(UGeckoInstruction _inst) {(this->*dynaOpTable19[_inst.SUBOP10])(_inst);}
void Jit64::DynaRunTable31(UGeckoInstruction _inst) {(this->*dynaOpTable31[_inst.SUBOP10])(_inst);}
void Jit64::DynaRunTable59(UGeckoInstruction _inst) {(this->*dynaOpTable59[_inst.SUBOP5 ])(_inst);}
void Jit64::DynaRunTable63(UGeckoInstruction _inst) {(this->*dynaOpTable63[_inst.SUBOP10])(_inst);}
struct GekkoOPTemplate
{
int opcode;
@ -78,21 +77,12 @@ static GekkoOPTemplate primarytable[] =
{28, &Jit64::reg_imm}, //"andi_rc", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_SET_CR0}},
{29, &Jit64::reg_imm}, //"andis_rc", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_SET_CR0}},
#if JITTEST
{32, &Jit64::lXz}, //"lwz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{33, &Jit64::lXz}, //"lwzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{34, &Jit64::lXz}, //"lbz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{35, &Jit64::Default}, //"lbzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{40, &Jit64::lXz}, //"lhz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{41, &Jit64::lXz}, //"lhzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
#else
{32, &Jit64::lXz}, //"lwz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{33, &Jit64::Default}, //"lwzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{34, &Jit64::lXz}, //"lbz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{35, &Jit64::Default}, //"lbzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{40, &Jit64::lXz}, //"lhz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{41, &Jit64::Default}, //"lhzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
#endif
{42, &Jit64::lha}, //"lha", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{43, &Jit64::Default}, //"lhau", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
@ -228,23 +218,7 @@ static GekkoOPTemplate table31[] =
{470, &Jit64::Default}, //"dcbi", OPTYPE_DCACHE, 0, 4}},
{758, &Jit64::Default}, //"dcba", OPTYPE_DCACHE, 0, 4}},
{1014, &Jit64::dcbz}, //"dcbz", OPTYPE_DCACHE, 0, 4}},
#if JITTEST
//load word
{23, &Jit64::lXzx}, //"lwzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{55, &Jit64::lXzx}, //"lwzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load halfword
{279, &Jit64::lXzx}, //"lhzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{311, &Jit64::lXzx}, //"lhzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load halfword signextend
{343, &Jit64::lhax}, //"lhax", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{375, &Jit64::Default}, //"lhaux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load byte
{87, &Jit64::lXzx}, //"lbzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{119, &Jit64::lXzx}, //"lbzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
#else
//load word
{23, &Jit64::lwzx}, //"lwzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{55, &Jit64::lwzux}, //"lwzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
@ -260,7 +234,7 @@ static GekkoOPTemplate table31[] =
//load byte
{87, &Jit64::lbzx}, //"lbzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{119, &Jit64::Default}, //"lbzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
#endif
//load byte reverse
{534, &Jit64::Default}, //"lwbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{790, &Jit64::Default}, //"lhbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
@ -336,11 +310,7 @@ static GekkoOPTemplate table31_2[] =
{10, &Jit64::Default}, //"addcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
{138, &Jit64::addex}, //"addex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{234, &Jit64::Default}, //"addmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
#if JITTEST
{202, &Jit64::addzex}, //"addzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
#else
{202, &Jit64::Default}, //"addzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
#endif
{491, &Jit64::Default}, //"divwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
{459, &Jit64::divwux}, //"divwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
{75, &Jit64::Default}, //"mulhwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
@ -403,11 +373,13 @@ static GekkoOPTemplate table63_2[] =
{31, &Jit64::fmaddXX}, //"fnmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
};
namespace JitTables
namespace Jit64Tables
{
void CompileInstruction(UGeckoInstruction _inst)
{
(jit.*dynaOpTable[_inst.OPCD])(_inst);
Jit64 *jit64 = (Jit64 *)jit;
(jit64->*dynaOpTable[_inst.OPCD])(_inst);
GekkoOPInfo *info = GetOpInfo(_inst);
if (info) {
#ifdef OPLOG
@ -416,11 +388,12 @@ void CompileInstruction(UGeckoInstruction _inst)
}
#endif
info->compileCount++;
info->lastUse = jit.js.compilerPC;
info->lastUse = jit->js.compilerPC;
} else {
PanicAlert("Tried to compile illegal (or unknown) instruction %08x, at %08x", _inst.hex, jit.js.compilerPC);
PanicAlert("Tried to compile illegal (or unknown) instruction %08x, at %08x", _inst.hex, jit->js.compilerPC);
}
}
void InitTables()
{
//clear
@ -512,4 +485,5 @@ void InitTables()
}
}
}
}
} // namespace

View File

@ -15,18 +15,14 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifndef JIT_TABLES_H
#define JIT_TABLES_H
#ifndef JIT64_TABLES_H
#define JIT64_TABLES_H
#include "../Gekko.h"
#include "../PPCTables.h"
#if defined JITTEST && JITTEST
#include "../Jit64IL/Jit.h"
#else
#include "../Jit64/Jit.h"
#endif
namespace JitTables
namespace Jit64Tables
{
void CompileInstruction(UGeckoInstruction _inst);
void InitTables();

View File

@ -33,12 +33,9 @@
#include "JitAsm.h"
using namespace Gen;
int blocksExecuted;
static int temp32;
bool compareEnabled = false;
//TODO - make an option
//#if _DEBUG
static bool enableDebug = false;
@ -56,21 +53,21 @@ static bool enableStatistics = false;
//RBX - Base pointer of memory
//R15 - Pointer to array of block pointers
AsmRoutineManager asm_routines;
Jit64AsmRoutineManager asm_routines;
// PLAN: no more block numbers - crazy opcodes just contain offset within
// dynarec buffer
// At this offset - 4, there is an int specifying the block number.
void AsmRoutineManager::Generate()
void Jit64AsmRoutineManager::Generate()
{
enterCode = AlignCode16();
ABI_PushAllCalleeSavedRegsAndAdjustStack();
#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();
@ -94,17 +91,13 @@ void AsmRoutineManager::Generate()
FixupBranch notfound = J_CC(CC_NZ);
BSWAP(32, EAX);
//IDEA - we have 26 bits, why not just use offsets from base of code?
if (enableStatistics)
{
ADD(32, M(&blocksExecuted), Imm8(1));
}
if (enableDebug)
{
ADD(32, M(&PowerPC::ppcState.DebugCount), Imm8(1));
}
//grab from list and jump to it
#ifdef _M_IX86
MOV(32, R(EDX), ImmPtr(jit.GetBlockCache()->GetCodePointers()));
MOV(32, R(EDX), ImmPtr(jit->GetBlockCache()->GetCodePointers()));
JMPptr(MComplex(EDX, EAX, 4, 0));
#else
JMPptr(MComplex(R15, RAX, 8, 0));
@ -166,9 +159,9 @@ void AsmRoutineManager::Generate()
AND(32, R(EAX), Imm32(JIT_ICACHE_MASK));
#ifdef _M_IX86
MOV(32, R(EAX), MDisp(EAX, (u32)jit.GetBlockCache()->GetICache()));
MOV(32, R(EAX), MDisp(EAX, (u32)jit->GetBlockCache()->GetICache()));
#else
MOV(64, R(RSI), Imm64((u64)jit.GetBlockCache()->GetICache()));
MOV(64, R(RSI), Imm64((u64)jit->GetBlockCache()->GetICache()));
MOV(32, R(EAX), MComplex(RSI, EAX, SCALE_1, 0));
#endif
@ -177,9 +170,9 @@ void AsmRoutineManager::Generate()
AND(32, R(EAX), Imm32(JIT_ICACHEEX_MASK));
#ifdef _M_IX86
MOV(32, R(EAX), MDisp(EAX, (u32)jit.GetBlockCache()->GetICacheEx()));
MOV(32, R(EAX), MDisp(EAX, (u32)jit->GetBlockCache()->GetICacheEx()));
#else
MOV(64, R(RSI), Imm64((u64)jit.GetBlockCache()->GetICacheEx()));
MOV(64, R(RSI), Imm64((u64)jit->GetBlockCache()->GetICacheEx()));
MOV(32, R(EAX), MComplex(RSI, EAX, SCALE_1, 0));
#endif
@ -188,9 +181,9 @@ void AsmRoutineManager::Generate()
AND(32, R(EAX), Imm32(JIT_ICACHE_MASK));
#ifdef _M_IX86
MOV(32, R(EAX), MDisp(EAX, (u32)jit.GetBlockCache()->GetICacheVMEM()));
MOV(32, R(EAX), MDisp(EAX, (u32)jit->GetBlockCache()->GetICacheVMEM()));
#else
MOV(64, R(RSI), Imm64((u64)jit.GetBlockCache()->GetICacheVMEM()));
MOV(64, R(RSI), Imm64((u64)jit->GetBlockCache()->GetICacheVMEM()));
MOV(32, R(EAX), MComplex(RSI, EAX, SCALE_1, 0));
#endif
@ -216,7 +209,7 @@ void AsmRoutineManager::Generate()
GenerateCommon();
}
void AsmRoutineManager::GenerateCommon()
void Jit64AsmRoutineManager::GenerateCommon()
{
// USES_CR
computeRc = AlignCode16();

View File

@ -15,8 +15,8 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifndef _JITASM_H
#define _JITASM_H
#ifndef _JIT64ASM_H
#define _JIT64ASM_H
#include "x64Emitter.h"
#include "../JitCommon/JitAsmCommon.h"
@ -35,7 +35,7 @@
// To add a new asm routine, just add another const here, and add the code to Generate.
// Also, possibly increase the size of the code buffer.
class AsmRoutineManager : public CommonAsmRoutines
class Jit64AsmRoutineManager : public CommonAsmRoutines
{
private:
void Generate();
@ -51,33 +51,8 @@ public:
void Shutdown() {
FreeCodeSpace();
}
// Public generated functions. Just CALL(M((void*)func)) them.
const u8 *enterCode;
const u8 *dispatcher;
const u8 *dispatcherNoCheck;
const u8 *dispatcherPcInEAX;
const u8 *fpException;
const u8 *computeRc;
const u8 *testExceptions;
const u8 *dispatchPcInEAX;
const u8 *doTiming;
const u8 *fifoDirectWrite8;
const u8 *fifoDirectWrite16;
const u8 *fifoDirectWrite32;
const u8 *fifoDirectWriteFloat;
const u8 *fifoDirectWriteXmm64;
const u8 *breakpointBailout;
bool compareEnabled;
};
extern AsmRoutineManager asm_routines;
extern Jit64AsmRoutineManager asm_routines;
#endif
#endif // _JIT64ASM_H

View File

@ -25,6 +25,17 @@
using namespace Gen;
using namespace PowerPC;
RegCache::RegCache() : emit(0) {
memset(locks, 0, sizeof(locks));
memset(xlocks, 0, sizeof(xlocks));
memset(saved_locks, 0, sizeof(saved_locks));
memset(saved_xlocks, 0, sizeof(saved_xlocks));
memset(regs, 0, sizeof(regs));
memset(xregs, 0, sizeof(xregs));
memset(saved_regs, 0, sizeof(saved_regs));
memset(saved_xregs, 0, sizeof(saved_xregs));
}
void RegCache::Start(PPCAnalyst::BlockRegStats &stats)
{
for (int i = 0; i < NUMXREGS; i++)

View File

@ -15,8 +15,8 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#ifndef _JITREGCACHE_H
#define _JITREGCACHE_H
#ifndef _JIT64REGCACHE_H
#define _JIT64REGCACHE_H
#include "x64Emitter.h"
@ -75,6 +75,8 @@ protected:
XEmitter *emit;
public:
RegCache();
virtual ~RegCache() {}
virtual void Start(PPCAnalyst::BlockRegStats &stats) = 0;
@ -147,4 +149,4 @@ public:
OpArg GetDefaultLocation(int reg) const;
};
#endif
#endif // _JIT64REGCACHE_H

View File

@ -527,15 +527,6 @@ void Jit64::divwux(UGeckoInstruction inst) {
}
}
u32 Helper_Mask(u8 mb, u8 me)
{
return (((mb > me) ?
~(((u32)-1 >> mb) ^ ((me >= 31) ? 0 : (u32) -1 >> (me + 1)))
:
(((u32)-1 >> mb) ^ ((me >= 31) ? 0 : (u32) -1 >> (me + 1))))
);
}
void Jit64::addx(UGeckoInstruction inst)
{
INSTRUCTION_START

View File

@ -19,7 +19,7 @@
// Should give a very noticable speed boost to paired single heavy code.
#include "Common.h"
#include "Thunk.h"
#include "../PowerPC.h"
#include "../../Core.h"

View File

@ -134,8 +134,8 @@ Fix profiled loads/stores to work safely. On 32-bit, one solution is to
#include "../../CoreTiming.h"
#include "Thunk.h"
#include "../../HW/Memmap.h"
#include "JitAsm.h"
#include "Jit.h"
#include "JitILAsm.h"
#include "JitIL.h"
#include "../../HW/GPFifo.h"
#include "../../Core.h"
using namespace Gen;

View File

@ -42,8 +42,8 @@ The register allocation is just a simple forward greedy allocator.
#include "../../CoreTiming.h"
#include "Thunk.h"
#include "../../HW/Memmap.h"
#include "JitAsm.h"
#include "Jit.h"
#include "JitILAsm.h"
#include "JitIL.h"
#include "../../HW/GPFifo.h"
#include "../../Core.h"
#include "x64Emitter.h"
@ -52,7 +52,7 @@ using namespace IREmitter;
using namespace Gen;
struct RegInfo {
Jit64* Jit;
JitIL *Jit;
IRBuilder* Build;
InstLoc FirstI;
std::vector<unsigned> IInfo;
@ -65,7 +65,7 @@ struct RegInfo {
unsigned numProfiledLoads;
unsigned exitNumber;
RegInfo(Jit64* j, InstLoc f, unsigned insts) : Jit(j), FirstI(f), IInfo(insts) {
RegInfo(JitIL* 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 (Jit64::*op)(int, const OpArg&,
void (JitIL::*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 (Jit64::*op)(X64Reg, OpArg)) {
void (JitIL::*op)(X64Reg, OpArg)) {
X64Reg reg;
if (RI.IInfo[I - RI.FirstI] & 4) {
reg = fregEnsureInReg(RI, getOp1(I));
@ -577,7 +577,7 @@ static void regEmitMemStore(RegInfo& RI, InstLoc I, unsigned Size) {
regClearInst(RI, getOp1(I));
}
static void regEmitShiftInst(RegInfo& RI, InstLoc I, void (Jit64::*op)(int, OpArg, OpArg))
static void regEmitShiftInst(RegInfo& RI, InstLoc I, void (JitIL::*op)(int, OpArg, OpArg))
{
X64Reg reg = regBinLHSReg(RI, I);
if (isImm(*getOp2(I))) {
@ -634,7 +634,7 @@ static void regWriteExit(RegInfo& RI, InstLoc dest) {
}
RI.Jit->Cleanup();
RI.Jit->SUB(32, M(&CoreTiming::downcount), Imm32(RI.Jit->js.downcountAmount));
RI.Jit->JMP(asm_routines.doReJit, true);
RI.Jit->JMP(((JitIL *)jit)->asm_routines.doReJit, true);
return;
}
if (isImm(*dest)) {
@ -646,7 +646,7 @@ static void regWriteExit(RegInfo& RI, InstLoc dest) {
}
}
static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool MakeProfile) {
static void DoWriteCode(IRBuilder* ibuild, JitIL* Jit, bool UseProfile, bool MakeProfile) {
//printf("Writing block: %x\n", js.blockStart);
RegInfo RI(Jit, ibuild->getFirstInst(), ibuild->getNumInsts());
RI.Build = ibuild;
@ -994,27 +994,27 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
}
case And: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64::AND, true);
regEmitBinInst(RI, I, &JitIL::AND, true);
break;
}
case Xor: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64::XOR, true);
regEmitBinInst(RI, I, &JitIL::XOR, true);
break;
}
case Sub: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64::SUB);
regEmitBinInst(RI, I, &JitIL::SUB);
break;
}
case Or: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64::OR, true);
regEmitBinInst(RI, I, &JitIL::OR, true);
break;
}
case Add: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64::ADD, true);
regEmitBinInst(RI, I, &JitIL::ADD, true);
break;
}
case Mul: {
@ -1037,22 +1037,22 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
}
case Rol: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64::ROL);
regEmitShiftInst(RI, I, &JitIL::ROL);
break;
}
case Shl: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64::SHL);
regEmitShiftInst(RI, I, &JitIL::SHL);
break;
}
case Shrl: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64::SHR);
regEmitShiftInst(RI, I, &JitIL::SHR);
break;
}
case Sarl: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64::SAR);
regEmitShiftInst(RI, I, &JitIL::SAR);
break;
}
case ICmpEq: {
@ -1183,7 +1183,7 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
Jit->SHL(32, R(EDX), Imm8(3));
#endif
Jit->MOV(32, R(ECX), regLocForInst(RI, getOp1(I)));
Jit->CALLptr(MDisp(EDX, (u32)(u64)asm_routines.pairedLoadQuantized));
Jit->CALLptr(MDisp(EDX, (u32)(u64)(((JitIL *)jit)->asm_routines.pairedLoadQuantized)));
Jit->MOVAPD(reg, R(XMM0));
RI.fregs[reg] = I;
regNormalRegClear(RI, I);
@ -1242,7 +1242,7 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
#endif
Jit->MOV(32, R(ECX), regLocForInst(RI, getOp2(I)));
Jit->MOVAPD(XMM0, fregLocForInst(RI, getOp1(I)));
Jit->CALLptr(MDisp(EDX, (u32)(u64)asm_routines.pairedStoreQuantized));
Jit->CALLptr(MDisp(EDX, (u32)(u64)(((JitIL *)jit)->asm_routines.pairedStoreQuantized)));
if (RI.IInfo[I - RI.FirstI] & 4)
fregClearInst(RI, getOp1(I));
if (RI.IInfo[I - RI.FirstI] & 8)
@ -1376,17 +1376,17 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
}
case FSMul: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::MULSS);
fregEmitBinInst(RI, I, &JitIL::MULSS);
break;
}
case FSAdd: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::ADDSS);
fregEmitBinInst(RI, I, &JitIL::ADDSS);
break;
}
case FSSub: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::SUBSS);
fregEmitBinInst(RI, I, &JitIL::SUBSS);
break;
}
case FSRSqrt: {
@ -1399,17 +1399,17 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
}
case FDMul: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::MULSD);
fregEmitBinInst(RI, I, &JitIL::MULSD);
break;
}
case FDAdd: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::ADDSD);
fregEmitBinInst(RI, I, &JitIL::ADDSD);
break;
}
case FDSub: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::SUBSD);
fregEmitBinInst(RI, I, &JitIL::SUBSD);
break;
}
case FDCmpCR: {
@ -1443,17 +1443,17 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
}
case FPAdd: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::ADDPS);
fregEmitBinInst(RI, I, &JitIL::ADDPS);
break;
}
case FPMul: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::MULPS);
fregEmitBinInst(RI, I, &JitIL::MULPS);
break;
}
case FPSub: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64::SUBPS);
fregEmitBinInst(RI, I, &JitIL::SUBPS);
break;
}
case FPMerge00: {
@ -1518,7 +1518,7 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
Jit->ABI_CallFunction((void *)&PowerPC::OnIdleIL);
Jit->MOV(32, M(&PC), Imm32(ibuild->GetImmValue( getOp2(I) )));
Jit->JMP(asm_routines.testExceptions, true);
Jit->JMP(((JitIL *)jit)->asm_routines.testExceptions, true);
Jit->SetJumpTarget(cont);
if (RI.IInfo[I - RI.FirstI] & 4)
@ -1572,7 +1572,7 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
unsigned InstLoc = ibuild->GetImmValue(getOp1(I));
Jit->ABI_CallFunction((void *)&CoreTiming::Idle);
Jit->MOV(32, M(&PC), Imm32(InstLoc));
Jit->JMP(asm_routines.testExceptions, true);
Jit->JMP(((JitIL *)jit)->asm_routines.testExceptions, true);
break;
}
case SystemCall: {
@ -1580,7 +1580,7 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
Jit->Cleanup();
Jit->OR(32, M(&PowerPC::ppcState.Exceptions), Imm32(EXCEPTION_SYSCALL));
Jit->MOV(32, M(&PC), Imm32(InstLoc + 4));
Jit->JMP(asm_routines.testExceptions, true);
Jit->JMP(((JitIL *)jit)->asm_routines.testExceptions, true);
break;
}
case InterpreterBranch: {
@ -1635,13 +1635,13 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool Mak
Jit->UD2();
}
void Jit64::WriteCode() {
void JitIL::WriteCode() {
DoWriteCode(&ibuild, this, false, Core::GetStartupParameter().bJITProfiledReJIT);
}
void ProfiledReJit() {
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);
jit->SetCodePtr(jit->js.rewriteStart);
DoWriteCode(&((JitIL *)jit)->ibuild, (JitIL *)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);
}

View File

@ -31,16 +31,14 @@
#include "../PPCAnalyst.h"
#include "../../HW/Memmap.h"
#include "../../HW/GPFifo.h"
#include "Jit.h"
#include "JitAsm.h"
#include "../JitCommon/JitCache.h"
#include "../JitCommon/Jit_Tables.h"
#include "JitIL.h"
#include "JitILAsm.h"
#include "JitIL_Tables.h"
using namespace Gen;
using namespace PowerPC;
extern int blocksExecuted;
// Dolphin's PowerPC->x86 JIT dynamic recompiler
// (Nearly) all code by ector (hrydgard)
// Features:
@ -156,34 +154,22 @@ ps_adds1
*/
Jit64 jit;
int CODE_SIZE = 1024*1024*16;
static int CODE_SIZE = 1024*1024*16;
namespace CPUCompare
{
extern u32 m_BlockStart;
}
void Jit(u32 em_address)
void JitIL::Init()
{
jit.Jit(em_address);
}
void Jit64::Init()
{
asm_routines.compareEnabled = ::Core::g_CoreStartupParameter.bRunCompareClient;
if (Core::g_CoreStartupParameter.bJITUnlimitedCache)
CODE_SIZE = 1024*1024*8*8;
jo.optimizeStack = true;
jo.enableBlocklink = true; // Speed boost, but not 100% safe
#ifdef _M_X64
#ifdef JITTEST
jo.enableFastMem = false;
#else
jo.enableFastMem = Core::GetStartupParameter().bUseFastMem;
#endif
#else
jo.enableFastMem = false;
#endif
@ -200,14 +186,14 @@ void Jit64::Init()
asm_routines.Init();
}
void Jit64::ClearCache()
void JitIL::ClearCache()
{
blocks.Clear();
trampolines.ClearCodeSpace();
ClearCodeSpace();
}
void Jit64::Shutdown()
void JitIL::Shutdown()
{
FreeCodeSpace();
@ -217,7 +203,7 @@ void Jit64::Shutdown()
}
void Jit64::WriteCallInterpreter(UGeckoInstruction inst)
void JitIL::WriteCallInterpreter(UGeckoInstruction inst)
{
if (js.isLastInstruction)
{
@ -233,32 +219,32 @@ void Jit64::WriteCallInterpreter(UGeckoInstruction inst)
}
}
void Jit64::unknown_instruction(UGeckoInstruction inst)
void JitIL::unknown_instruction(UGeckoInstruction inst)
{
// CCPU::Break();
PanicAlert("unknown_instruction %08x - Fix me ;)", inst.hex);
}
void Jit64::Default(UGeckoInstruction _inst)
void JitIL::Default(UGeckoInstruction _inst)
{
ibuild.EmitInterpreterFallback(
ibuild.EmitIntConst(_inst.hex),
ibuild.EmitIntConst(js.compilerPC));
}
void Jit64::HLEFunction(UGeckoInstruction _inst)
void JitIL::HLEFunction(UGeckoInstruction _inst)
{
ABI_CallFunctionCC((void*)&HLE::Execute, js.compilerPC, _inst.hex);
MOV(32, R(EAX), M(&NPC));
WriteExitDestInEAX(0);
}
void Jit64::DoNothing(UGeckoInstruction _inst)
void JitIL::DoNothing(UGeckoInstruction _inst)
{
// Yup, just don't do anything.
}
void Jit64::NotifyBreakpoint(u32 em_address, bool set)
void JitIL::NotifyBreakpoint(u32 em_address, bool set)
{
int block_num = blocks.GetBlockNumberFromStartAddress(em_address);
if (block_num >= 0)
@ -271,7 +257,7 @@ static const bool ImHereDebug = false;
static const bool ImHereLog = false;
static std::map<u32, int> been_here;
void ImHere()
static void ImHere()
{
static FILE *f = 0;
if (ImHereLog)
@ -296,13 +282,13 @@ void ImHere()
been_here[PC] = 1;
}
void Jit64::Cleanup()
void JitIL::Cleanup()
{
if (jo.optimizeGatherPipe && js.fifoBytesThisBlock > 0)
ABI_CallFunction((void *)&GPFifo::CheckGatherPipe);
}
void Jit64::WriteExit(u32 destination, int exit_num)
void JitIL::WriteExit(u32 destination, int exit_num)
{
Cleanup();
SUB(32, M(&CoreTiming::downcount), js.downcountAmount > 127 ? Imm32(js.downcountAmount) : Imm8(js.downcountAmount));
@ -327,7 +313,7 @@ void Jit64::WriteExit(u32 destination, int exit_num)
}
}
void Jit64::WriteExitDestInEAX(int exit_num)
void JitIL::WriteExitDestInEAX(int exit_num)
{
MOV(32, M(&PC), R(EAX));
Cleanup();
@ -335,7 +321,7 @@ void Jit64::WriteExitDestInEAX(int exit_num)
JMP(asm_routines.dispatcher, true);
}
void Jit64::WriteRfiExitDestInEAX()
void JitIL::WriteRfiExitDestInEAX()
{
MOV(32, M(&PC), R(EAX));
Cleanup();
@ -343,7 +329,7 @@ void Jit64::WriteRfiExitDestInEAX()
JMP(asm_routines.testExceptions, true);
}
void Jit64::WriteExceptionExit(u32 exception)
void JitIL::WriteExceptionExit(u32 exception)
{
Cleanup();
OR(32, M(&PowerPC::ppcState.Exceptions), Imm32(exception));
@ -351,14 +337,14 @@ void Jit64::WriteExceptionExit(u32 exception)
JMP(asm_routines.testExceptions, true);
}
void STACKALIGN Jit64::Run()
void STACKALIGN JitIL::Run()
{
CompiledCode pExecAddr = (CompiledCode)asm_routines.enterCode;
pExecAddr();
//Will return when PowerPC::state changes
}
void Jit64::SingleStep()
void JitIL::SingleStep()
{
// NOT USED, NOT TESTED, PROBABLY NOT WORKING YET
// PanicAlert("Single");
@ -370,7 +356,7 @@ void Jit64::SingleStep()
pExecAddr();*/
}
void STACKALIGN Jit64::Jit(u32 em_address)
void STACKALIGN JitIL::Jit(u32 em_address)
{
if (GetSpaceLeft() < 0x10000 || blocks.IsFull())
{
@ -387,7 +373,7 @@ void STACKALIGN Jit64::Jit(u32 em_address)
blocks.FinalizeBlock(block_num, jo.enableBlocklink, DoJit(em_address, &code_buffer, b));
}
const u8* Jit64::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitBlock *b)
const u8* JitIL::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitBlock *b)
{
if (em_address == 0)
PanicAlert("ERROR : Trying to compile at 0. LR=%08x", LR);
@ -456,7 +442,9 @@ const u8* Jit64::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitB
}
if (!ops[i].skip)
JitTables::CompileInstruction(ops[i].inst);
{
JitILTables::CompileInstruction(ops[i].inst);
}
}
// Perform actual code generation

View File

@ -27,36 +27,19 @@
// * A flush simply does a conditional write to the appropriate CRx.
// * If flag available, branch code can become absolutely trivial.
#ifndef _JIT_H
#define _JIT_H
#ifndef _JITIL_H
#define _JITIL_H
#include "../PPCAnalyst.h"
#include "../JitCommon/JitBase.h"
#include "../JitCommon/JitCache.h"
#include "../JitCommon/JitBackpatch.h"
#include "../JitCommon/Jit_Util.h"
#include "x64Emitter.h"
#include "x64Analyzer.h"
#include "IR.h"
#ifdef _WIN32
#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
#include "../JitCommon/JitBase.h"
#include "JitILAsm.h"
// #define INSTRUCTION_START Default(inst); return;
// #define INSTRUCTION_START PPCTables::CountInstruction(inst);
@ -74,70 +57,21 @@ struct CONTEXT
#define DISABLE64
#endif
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 EmuCodeBlock
class JitIL : public JitBase
{
private:
struct JitState
{
u32 compilerPC;
u32 next_compilerPC;
u32 blockStart;
bool cancel;
UGeckoInstruction next_inst; // for easy peephole opt.
int instructionNumber;
int downcountAmount;
bool isLastInstruction;
bool forceUnsafeLoad;
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 fpAccurateFcmp;
bool enableFastMem;
bool optimizeGatherPipe;
bool fastInterrupts;
bool accurateSinglePrecision;
};
JitBlockCache blocks;
TrampolineCache trampolines;
// 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:
Jit64() : code_buffer(32000) {}
~Jit64() {}
JitILAsmRoutineManager asm_routines;
JitIL() : code_buffer(32000) {}
~JitIL() {}
JitState js;
JitOptions jo;
IREmitter::IRBuilder ibuild;
// Initialization, etc
@ -150,21 +84,29 @@ public:
void Jit(u32 em_address);
const u8* DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitBlock *b);
JitBlockCache *GetBlockCache() { return &blocks; }
void NotifyBreakpoint(u32 em_address, bool set);
void ClearCache();
const u8 *GetDispatcher() {
return asm_routines.dispatcher; // asm_routines.dispatcher
}
const CommonAsmRoutines *GetAsmRoutines() {
return &asm_routines;
}
const char *GetName() {
#ifdef _M_X64
return "JIT64IL";
#else
return "JIT32IL";
#endif
}
// Run!
void Run();
void SingleStep();
const u8 *BackPatch(u8 *codePtr, int accessType, u32 em_address, CONTEXT *ctx);
#define JIT_OPCODE 0
// Utilities for use by opcodes
void WriteExit(u32 destination, int exit_num);
@ -178,10 +120,10 @@ public:
void WriteFloatToConstRamAddress(const Gen::X64Reg& xmm_reg, u32 address);
void GenerateCarry(Gen::X64Reg temp_reg);
void tri_op(int d, int a, int b, bool reversible, void (XEmitter::*op)(Gen::X64Reg, Gen::OpArg));
void tri_op(int d, int a, int b, bool reversible, void (Gen::XEmitter::*op)(Gen::X64Reg, Gen::OpArg));
typedef u32 (*Operation)(u32 a, u32 b);
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);
void fp_tri_op(int d, int a, int b, bool reversible, bool dupe, void (XEmitter::*op)(Gen::X64Reg, Gen::OpArg));
void regimmop(int d, int a, bool binary, u32 value, Operation doop, void (Gen::XEmitter::*op)(int, const Gen::OpArg&, const Gen::OpArg&), bool Rc = false, bool carry = false);
void fp_tri_op(int d, int a, int b, bool reversible, bool dupe, void (Gen::XEmitter::*op)(Gen::X64Reg, Gen::OpArg));
void WriteCode();
@ -288,10 +230,8 @@ public:
void icbi(UGeckoInstruction inst);
};
extern Jit64 jit;
void Jit(u32 em_address);
void ProfiledReJit();
#endif
#endif // _JITIL_H

View File

@ -26,20 +26,17 @@
#include "CPUDetect.h"
#include "ABI.h"
#include "Jit.h"
#include "Thunk.h"
#include "../../HW/GPFifo.h"
#include "../../Core.h"
#include "JitAsm.h"
#include "JitIL.h"
#include "JitILAsm.h"
using namespace Gen;
int blocksExecuted;
static int temp32;
bool compareEnabled = false;
//TODO - make an option
//#if _DEBUG
static bool enableDebug = false;
@ -57,20 +54,20 @@ static bool enableStatistics = false;
//RBX - Base pointer of memory
//R15 - Pointer to array of block pointers
AsmRoutineManager asm_routines;
JitILAsmRoutineManager jitil_asm_routines;
// PLAN: no more block numbers - crazy opcodes just contain offset within
// dynarec buffer
// At this offset - 4, there is an int specifying the block number.
void AsmRoutineManager::Generate()
void JitILAsmRoutineManager::Generate()
{
enterCode = AlignCode16();
ABI_PushAllCalleeSavedRegsAndAdjustStack();
#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();
@ -96,17 +93,13 @@ void AsmRoutineManager::Generate()
FixupBranch notfound = J_CC(CC_NZ);
BSWAP(32, EAX);
//IDEA - we have 26 bits, why not just use offsets from base of code?
if (enableStatistics)
{
ADD(32, M(&blocksExecuted), Imm8(1));
}
if (enableDebug)
{
ADD(32, M(&PowerPC::ppcState.DebugCount), Imm8(1));
}
//grab from list and jump to it
#ifdef _M_IX86
MOV(32, R(EDX), ImmPtr(jit.GetBlockCache()->GetCodePointers()));
MOV(32, R(EDX), ImmPtr(jit->GetBlockCache()->GetCodePointers()));
JMPptr(MComplex(EDX, EAX, 4, 0));
#else
JMPptr(MComplex(R15, RAX, 8, 0));
@ -171,9 +164,9 @@ void AsmRoutineManager::Generate()
AND(32, R(EAX), Imm32(JIT_ICACHE_MASK));
#ifdef _M_IX86
MOV(32, R(EAX), MDisp(EAX, (u32)jit.GetBlockCache()->GetICache()));
MOV(32, R(EAX), MDisp(EAX, (u32)jit->GetBlockCache()->GetICache()));
#else
MOV(64, R(RSI), Imm64((u64)jit.GetBlockCache()->GetICache()));
MOV(64, R(RSI), Imm64((u64)jit->GetBlockCache()->GetICache()));
MOV(32, R(EAX), MComplex(RSI, EAX, SCALE_1, 0));
#endif
@ -182,9 +175,9 @@ void AsmRoutineManager::Generate()
AND(32, R(EAX), Imm32(JIT_ICACHEEX_MASK));
#ifdef _M_IX86
MOV(32, R(EAX), MDisp(EAX, (u32)jit.GetBlockCache()->GetICacheEx()));
MOV(32, R(EAX), MDisp(EAX, (u32)jit->GetBlockCache()->GetICacheEx()));
#else
MOV(64, R(RSI), Imm64((u64)jit.GetBlockCache()->GetICacheEx()));
MOV(64, R(RSI), Imm64((u64)jit->GetBlockCache()->GetICacheEx()));
MOV(32, R(EAX), MComplex(RSI, EAX, SCALE_1, 0));
#endif
@ -193,9 +186,9 @@ void AsmRoutineManager::Generate()
AND(32, R(EAX), Imm32(JIT_ICACHE_MASK));
#ifdef _M_IX86
MOV(32, R(EAX), MDisp(EAX, (u32)jit.GetBlockCache()->GetICacheVMEM()));
MOV(32, R(EAX), MDisp(EAX, (u32)jit->GetBlockCache()->GetICacheVMEM()));
#else
MOV(64, R(RSI), Imm64((u64)jit.GetBlockCache()->GetICacheVMEM()));
MOV(64, R(RSI), Imm64((u64)jit->GetBlockCache()->GetICacheVMEM()));
MOV(32, R(EAX), MComplex(RSI, EAX, SCALE_1, 0));
#endif
@ -215,7 +208,7 @@ void AsmRoutineManager::Generate()
GenerateCommon();
}
void AsmRoutineManager::GenerateCommon()
void JitILAsmRoutineManager::GenerateCommon()
{
// USES_CR
computeRc = AlignCode16();

View File

@ -35,7 +35,7 @@
// To add a new asm routine, just add another const here, and add the code to Generate.
// Also, possibly increase the size of the code buffer.
class AsmRoutineManager : public CommonAsmRoutines
class JitILAsmRoutineManager : public CommonAsmRoutines
{
private:
void Generate();
@ -52,35 +52,9 @@ public:
FreeCodeSpace();
}
// Public generated functions. Just CALL(M((void*)func)) them.
const u8 *enterCode;
const u8 *dispatcher;
const u8 *dispatcherNoCheck;
const u8 *dispatcherPcInEAX;
const u8 *fpException;
const u8 *computeRc;
const u8 *testExceptions;
const u8 *dispatchPcInEAX;
const u8 *doTiming;
const u8 *fifoDirectWrite8;
const u8 *fifoDirectWrite16;
const u8 *fifoDirectWrite32;
const u8 *fifoDirectWriteFloat;
const u8 *fifoDirectWriteXmm64;
const u8 *breakpointBailout;
const u8 *doReJit;
bool compareEnabled;
};
extern AsmRoutineManager asm_routines;
extern JitILAsmRoutineManager jitil_asm_routines;
#endif

View File

@ -23,8 +23,8 @@
#include "../PPCTables.h"
#include "x64Emitter.h"
#include "Jit.h"
#include "JitAsm.h"
#include "JitIL.h"
#include "JitILAsm.h"
#include "../../HW/Memmap.h"
@ -44,17 +44,17 @@
using namespace Gen;
void Jit64::sc(UGeckoInstruction inst)
void JitIL::sc(UGeckoInstruction inst)
{
ibuild.EmitSystemCall(ibuild.EmitIntConst(js.compilerPC));
}
void Jit64::rfi(UGeckoInstruction inst)
void JitIL::rfi(UGeckoInstruction inst)
{
ibuild.EmitRFIExit();
}
void Jit64::bx(UGeckoInstruction inst)
void JitIL::bx(UGeckoInstruction inst)
{
NORMALBRANCH_START
INSTRUCTION_START;
@ -113,7 +113,7 @@ static IREmitter::InstLoc TestBranch(IREmitter::IRBuilder& ibuild, UGeckoInstruc
return Test;
}
void Jit64::bcx(UGeckoInstruction inst)
void JitIL::bcx(UGeckoInstruction inst)
{
NORMALBRANCH_START
if (inst.LK)
@ -144,7 +144,7 @@ void Jit64::bcx(UGeckoInstruction inst)
ibuild.EmitBranchUncond(ibuild.EmitIntConst(js.compilerPC + 4));
}
void Jit64::bcctrx(UGeckoInstruction inst)
void JitIL::bcctrx(UGeckoInstruction inst)
{
NORMALBRANCH_START
if ((inst.BO & 4) == 0) {
@ -173,7 +173,7 @@ void Jit64::bcctrx(UGeckoInstruction inst)
ibuild.EmitBranchUncond(destination);
}
void Jit64::bclrx(UGeckoInstruction inst)
void JitIL::bclrx(UGeckoInstruction inst)
{
NORMALBRANCH_START
if (inst.hex == 0x4e800020) {

View File

@ -22,12 +22,12 @@
#include "../PPCTables.h"
#include "x64Emitter.h"
#include "Jit.h"
#include "JitIL.h"
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
void Jit64::fp_arith_s(UGeckoInstruction inst)
void JitIL::fp_arith_s(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@ -70,7 +70,7 @@ void Jit64::fp_arith_s(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64::fmaddXX(UGeckoInstruction inst)
void JitIL::fmaddXX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@ -98,7 +98,7 @@ void Jit64::fmaddXX(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64::fmrx(UGeckoInstruction inst)
void JitIL::fmrx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@ -110,7 +110,7 @@ void Jit64::fmrx(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64::fcmpx(UGeckoInstruction inst)
void JitIL::fcmpx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@ -122,7 +122,7 @@ void Jit64::fcmpx(UGeckoInstruction inst)
ibuild.EmitStoreCR(res, inst.CRFD);
}
void Jit64::fsign(UGeckoInstruction inst)
void JitIL::fsign(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)

View File

@ -24,8 +24,8 @@
#include "../PPCTables.h"
#include "x64Emitter.h"
#include "Jit.h"
#include "JitAsm.h"
#include "JitIL.h"
#include "JitILAsm.h"
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
@ -37,7 +37,7 @@ static void ComputeRC(IREmitter::IRBuilder& ibuild,
ibuild.EmitStoreCR(res, 0);
}
void Jit64::reg_imm(UGeckoInstruction inst)
void JitIL::reg_imm(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -105,7 +105,7 @@ void Jit64::reg_imm(UGeckoInstruction inst)
}
}
void Jit64::cmpXX(UGeckoInstruction inst)
void JitIL::cmpXX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -129,7 +129,7 @@ void Jit64::cmpXX(UGeckoInstruction inst)
ibuild.EmitStoreCR(res, inst.CRFD);
}
void Jit64::orx(UGeckoInstruction inst)
void JitIL::orx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -142,7 +142,7 @@ void Jit64::orx(UGeckoInstruction inst)
// m_GPR[_inst.RA] = m_GPR[_inst.RS] ^ m_GPR[_inst.RB];
void Jit64::xorx(UGeckoInstruction inst)
void JitIL::xorx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -153,7 +153,7 @@ void Jit64::xorx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::andx(UGeckoInstruction inst)
void JitIL::andx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -164,7 +164,7 @@ void Jit64::andx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::extsbx(UGeckoInstruction inst)
void JitIL::extsbx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -175,7 +175,7 @@ void Jit64::extsbx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::extshx(UGeckoInstruction inst)
void JitIL::extshx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -186,7 +186,7 @@ void Jit64::extshx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::subfic(UGeckoInstruction inst)
void JitIL::subfic(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -205,7 +205,7 @@ void Jit64::subfic(UGeckoInstruction inst)
ibuild.EmitStoreCarry(test);
}
void Jit64::subfcx(UGeckoInstruction inst)
void JitIL::subfcx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -222,7 +222,7 @@ void Jit64::subfcx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::subfex(UGeckoInstruction inst)
void JitIL::subfex(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -243,7 +243,7 @@ void Jit64::subfex(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::subfx(UGeckoInstruction inst)
void JitIL::subfx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -255,7 +255,7 @@ void Jit64::subfx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::mulli(UGeckoInstruction inst)
void JitIL::mulli(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -264,7 +264,7 @@ void Jit64::mulli(UGeckoInstruction inst)
ibuild.EmitStoreGReg(val, inst.RD);
}
void Jit64::mullwx(UGeckoInstruction inst)
void JitIL::mullwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -275,7 +275,7 @@ void Jit64::mullwx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::mulhwux(UGeckoInstruction inst)
void JitIL::mulhwux(UGeckoInstruction inst)
{
Default(inst); return;
#if 0
@ -310,7 +310,7 @@ void Jit64::mulhwux(UGeckoInstruction inst)
}
// skipped some of the special handling in here - if we get crashes, let the interpreter handle this op
void Jit64::divwux(UGeckoInstruction inst) {
void JitIL::divwux(UGeckoInstruction inst) {
Default(inst); return;
#if 0
int a = inst.RA, b = inst.RB, d = inst.RD;
@ -334,16 +334,7 @@ void Jit64::divwux(UGeckoInstruction inst) {
#endif
}
u32 Helper_Mask(u8 mb, u8 me)
{
return (((mb > me) ?
~(((u32)-1 >> mb) ^ ((me >= 31) ? 0 : (u32) -1 >> (me + 1)))
:
(((u32)-1 >> mb) ^ ((me >= 31) ? 0 : (u32) -1 >> (me + 1))))
);
}
void Jit64::addx(UGeckoInstruction inst)
void JitIL::addx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -354,7 +345,7 @@ void Jit64::addx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::addzex(UGeckoInstruction inst)
void JitIL::addzex(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -368,7 +359,7 @@ void Jit64::addzex(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
// This can be optimized
void Jit64::addex(UGeckoInstruction inst)
void JitIL::addex(UGeckoInstruction inst)
{
Default(inst); return;
#if 0
@ -399,7 +390,7 @@ void Jit64::addex(UGeckoInstruction inst)
#endif
}
void Jit64::rlwinmx(UGeckoInstruction inst)
void JitIL::rlwinmx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -413,7 +404,7 @@ void Jit64::rlwinmx(UGeckoInstruction inst)
}
void Jit64::rlwimix(UGeckoInstruction inst)
void JitIL::rlwimix(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -429,7 +420,7 @@ void Jit64::rlwimix(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::rlwnmx(UGeckoInstruction inst)
void JitIL::rlwnmx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -442,7 +433,7 @@ void Jit64::rlwnmx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::negx(UGeckoInstruction inst)
void JitIL::negx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -453,7 +444,7 @@ void Jit64::negx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::srwx(UGeckoInstruction inst)
void JitIL::srwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -472,7 +463,7 @@ void Jit64::srwx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::slwx(UGeckoInstruction inst)
void JitIL::slwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -491,7 +482,7 @@ void Jit64::slwx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64::srawx(UGeckoInstruction inst)
void JitIL::srawx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -514,7 +505,7 @@ void Jit64::srawx(UGeckoInstruction inst)
ibuild.EmitStoreCarry(test);
}
void Jit64::srawix(UGeckoInstruction inst)
void JitIL::srawix(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@ -531,7 +522,7 @@ void Jit64::srawix(UGeckoInstruction inst)
}
// count leading zeroes
void Jit64::cntlzwx(UGeckoInstruction inst)
void JitIL::cntlzwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)

View File

@ -29,13 +29,13 @@
#include "x64Emitter.h"
#include "ABI.h"
#include "Jit.h"
#include "JitAsm.h"
#include "JitIL.h"
#include "JitILAsm.h"
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
void Jit64::lhax(UGeckoInstruction inst)
void JitIL::lhax(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -47,7 +47,7 @@ void Jit64::lhax(UGeckoInstruction inst)
ibuild.EmitStoreGReg(val, inst.RD);
}
void Jit64::lXz(UGeckoInstruction inst)
void JitIL::lXz(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -67,7 +67,7 @@ void Jit64::lXz(UGeckoInstruction inst)
ibuild.EmitStoreGReg(val, inst.RD);
}
void Jit64::lha(UGeckoInstruction inst)
void JitIL::lha(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -80,7 +80,7 @@ void Jit64::lha(UGeckoInstruction inst)
ibuild.EmitStoreGReg(val, inst.RD);
}
void Jit64::lXzx(UGeckoInstruction inst)
void JitIL::lXzx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -102,7 +102,7 @@ void Jit64::lXzx(UGeckoInstruction inst)
}
// Zero cache line.
void Jit64::dcbz(UGeckoInstruction inst)
void JitIL::dcbz(UGeckoInstruction inst)
{
Default(inst); return;
@ -127,7 +127,7 @@ void Jit64::dcbz(UGeckoInstruction inst)
#endif
}
void Jit64::stX(UGeckoInstruction inst)
void JitIL::stX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -146,7 +146,7 @@ void Jit64::stX(UGeckoInstruction inst)
}
}
void Jit64::stXx(UGeckoInstruction inst)
void JitIL::stXx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -165,7 +165,7 @@ void Jit64::stXx(UGeckoInstruction inst)
}
// A few games use these heavily in video codecs. (GFZP01 @ 0x80020E18)
void Jit64::lmw(UGeckoInstruction inst)
void JitIL::lmw(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -180,7 +180,7 @@ void Jit64::lmw(UGeckoInstruction inst)
}
}
void Jit64::stmw(UGeckoInstruction inst)
void JitIL::stmw(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStore)
@ -195,7 +195,7 @@ void Jit64::stmw(UGeckoInstruction inst)
}
}
void Jit64::icbi(UGeckoInstruction inst)
void JitIL::icbi(UGeckoInstruction inst)
{
Default(inst);
ibuild.EmitBranchUncond(ibuild.EmitIntConst(js.compilerPC + 4));

View File

@ -29,8 +29,8 @@
#include "x64Emitter.h"
#include "ABI.h"
#include "Jit.h"
#include "JitAsm.h"
#include "JitIL.h"
#include "JitILAsm.h"
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
@ -39,7 +39,7 @@
// and pshufb could help a lot.
// Also add hacks for things like lfs/stfs the same reg consecutively, that is, simple memory moves.
void Jit64::lfs(UGeckoInstruction inst)
void JitIL::lfs(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStoreFloating)
@ -52,7 +52,7 @@ void Jit64::lfs(UGeckoInstruction inst)
}
void Jit64::lfd(UGeckoInstruction inst)
void JitIL::lfd(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStoreFloating)
@ -66,7 +66,7 @@ void Jit64::lfd(UGeckoInstruction inst)
}
void Jit64::stfd(UGeckoInstruction inst)
void JitIL::stfd(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStoreFloating)
@ -81,7 +81,7 @@ void Jit64::stfd(UGeckoInstruction inst)
}
void Jit64::stfs(UGeckoInstruction inst)
void JitIL::stfs(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStoreFloating)
@ -97,7 +97,7 @@ void Jit64::stfs(UGeckoInstruction inst)
}
void Jit64::stfsx(UGeckoInstruction inst)
void JitIL::stfsx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStoreFloating)
@ -111,7 +111,7 @@ void Jit64::stfsx(UGeckoInstruction inst)
}
void Jit64::lfsx(UGeckoInstruction inst)
void JitIL::lfsx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStoreFloating)

View File

@ -27,13 +27,13 @@
#include "x64Emitter.h"
#include "ABI.h"
#include "Jit.h"
#include "JitAsm.h"
#include "JitIL.h"
#include "JitILAsm.h"
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
void Jit64::psq_st(UGeckoInstruction inst)
void JitIL::psq_st(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStorePaired)
@ -48,7 +48,7 @@ void Jit64::psq_st(UGeckoInstruction inst)
ibuild.EmitStorePaired(val, addr, inst.I);
}
void Jit64::psq_l(UGeckoInstruction inst)
void JitIL::psq_l(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(LoadStorePaired)

View File

@ -23,29 +23,29 @@
#include "x64Emitter.h"
#include "../../HW/GPFifo.h"
#include "Jit.h"
#include "JitIL.h"
void Jit64::ps_mr(UGeckoInstruction inst)
void JitIL::ps_mr(UGeckoInstruction inst)
{
Default(inst); return;
}
void Jit64::ps_sel(UGeckoInstruction inst)
void JitIL::ps_sel(UGeckoInstruction inst)
{
Default(inst); return;
}
void Jit64::ps_sign(UGeckoInstruction inst)
void JitIL::ps_sign(UGeckoInstruction inst)
{
Default(inst); return;
}
void Jit64::ps_rsqrte(UGeckoInstruction inst)
void JitIL::ps_rsqrte(UGeckoInstruction inst)
{
Default(inst); return;
}
void Jit64::ps_arith(UGeckoInstruction inst)
void JitIL::ps_arith(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Paired)
@ -74,7 +74,7 @@ void Jit64::ps_arith(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64::ps_sum(UGeckoInstruction inst)
void JitIL::ps_sum(UGeckoInstruction inst)
{
// FIXME: This operation strikes me as a bit strange...
// perhaps we can optimize it depending on the users?
@ -95,7 +95,7 @@ void Jit64::ps_sum(UGeckoInstruction inst)
}
void Jit64::ps_muls(UGeckoInstruction inst)
void JitIL::ps_muls(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Paired)
@ -120,7 +120,7 @@ void Jit64::ps_muls(UGeckoInstruction inst)
//TODO: find easy cases and optimize them, do a breakout like ps_arith
void Jit64::ps_mergeXX(UGeckoInstruction inst)
void JitIL::ps_mergeXX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Paired)
@ -153,7 +153,7 @@ void Jit64::ps_mergeXX(UGeckoInstruction inst)
}
void Jit64::ps_maddXX(UGeckoInstruction inst)
void JitIL::ps_maddXX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Paired)

View File

@ -26,12 +26,12 @@
#include "ABI.h"
#include "Thunk.h"
#include "Jit.h"
#include "JitIL.h"
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
void Jit64::mtspr(UGeckoInstruction inst)
void JitIL::mtspr(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(SystemRegisters)
@ -67,7 +67,7 @@ void Jit64::mtspr(UGeckoInstruction inst)
}
}
void Jit64::mfspr(UGeckoInstruction inst)
void JitIL::mfspr(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(SystemRegisters)
@ -104,7 +104,7 @@ void Jit64::mfspr(UGeckoInstruction inst)
// =======================================================================================
// Don't interpret this, if we do we get thrown out
// --------------
void Jit64::mtmsr(UGeckoInstruction inst)
void JitIL::mtmsr(UGeckoInstruction inst)
{
ibuild.EmitStoreMSR(ibuild.EmitLoadGReg(inst.RS));
ibuild.EmitBranchUncond(ibuild.EmitIntConst(js.compilerPC + 4));
@ -112,21 +112,21 @@ void Jit64::mtmsr(UGeckoInstruction inst)
// ==============
void Jit64::mfmsr(UGeckoInstruction inst)
void JitIL::mfmsr(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(SystemRegisters)
ibuild.EmitStoreGReg(ibuild.EmitLoadMSR(), inst.RD);
}
void Jit64::mftb(UGeckoInstruction inst)
void JitIL::mftb(UGeckoInstruction inst)
{
INSTRUCTION_START;
JITDISABLE(SystemRegisters)
mfspr(inst);
}
void Jit64::mfcr(UGeckoInstruction inst)
void JitIL::mfcr(UGeckoInstruction inst)
{
Default(inst); return;
#if 0
@ -147,7 +147,7 @@ void Jit64::mfcr(UGeckoInstruction inst)
#endif
}
void Jit64::mtcrf(UGeckoInstruction inst)
void JitIL::mtcrf(UGeckoInstruction inst)
{
Default(inst); return;
#if 0

View File

@ -0,0 +1,496 @@
// 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.
// 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/
#include "JitIL_Tables.h"
// Should be moved in to the Jit class
typedef void (JitIL::*_Instruction) (UGeckoInstruction instCode);
static _Instruction dynaOpTable[64];
static _Instruction dynaOpTable4[1024];
static _Instruction dynaOpTable19[1024];
static _Instruction dynaOpTable31[1024];
static _Instruction dynaOpTable59[32];
static _Instruction dynaOpTable63[1024];
void JitIL::DynaRunTable4(UGeckoInstruction _inst) {(this->*dynaOpTable4 [_inst.SUBOP10])(_inst);}
void JitIL::DynaRunTable19(UGeckoInstruction _inst) {(this->*dynaOpTable19[_inst.SUBOP10])(_inst);}
void JitIL::DynaRunTable31(UGeckoInstruction _inst) {(this->*dynaOpTable31[_inst.SUBOP10])(_inst);}
void JitIL::DynaRunTable59(UGeckoInstruction _inst) {(this->*dynaOpTable59[_inst.SUBOP5 ])(_inst);}
void JitIL::DynaRunTable63(UGeckoInstruction _inst) {(this->*dynaOpTable63[_inst.SUBOP10])(_inst);}
struct GekkoOPTemplate
{
int opcode;
_Instruction Inst;
//GekkoOPInfo opinfo; // Doesn't need opinfo, Interpreter fills it out
int runCount;
};
static GekkoOPTemplate primarytable[] =
{
{4, &JitIL::DynaRunTable4}, //"RunTable4", OPTYPE_SUBTABLE | (4<<24), 0}},
{19, &JitIL::DynaRunTable19}, //"RunTable19", OPTYPE_SUBTABLE | (19<<24), 0}},
{31, &JitIL::DynaRunTable31}, //"RunTable31", OPTYPE_SUBTABLE | (31<<24), 0}},
{59, &JitIL::DynaRunTable59}, //"RunTable59", OPTYPE_SUBTABLE | (59<<24), 0}},
{63, &JitIL::DynaRunTable63}, //"RunTable63", OPTYPE_SUBTABLE | (63<<24), 0}},
{16, &JitIL::bcx}, //"bcx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{18, &JitIL::bx}, //"bx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{1, &JitIL::HLEFunction}, //"HLEFunction", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{2, &JitIL::Default}, //"DynaBlock", OPTYPE_SYSTEM, 0}},
{3, &JitIL::Default}, //"twi", OPTYPE_SYSTEM, 0}},
{17, &JitIL::sc}, //"sc", OPTYPE_SYSTEM, FL_ENDBLOCK, 1}},
{7, &JitIL::mulli}, //"mulli", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_RC_BIT, 2}},
{8, &JitIL::subfic}, //"subfic", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_SET_CA}},
{10, &JitIL::cmpXX}, //"cmpli", OPTYPE_INTEGER, FL_IN_A | FL_SET_CRn}},
{11, &JitIL::cmpXX}, //"cmpi", OPTYPE_INTEGER, FL_IN_A | FL_SET_CRn}},
{12, &JitIL::reg_imm}, //"addic", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_SET_CA}},
{13, &JitIL::reg_imm}, //"addic_rc", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_SET_CR0}},
{14, &JitIL::reg_imm}, //"addi", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A0}},
{15, &JitIL::reg_imm}, //"addis", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A0}},
{20, &JitIL::rlwimix}, //"rlwimix", OPTYPE_INTEGER, FL_OUT_A | FL_IN_A | FL_IN_S | FL_RC_BIT}},
{21, &JitIL::rlwinmx}, //"rlwinmx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
{23, &JitIL::rlwnmx}, //"rlwnmx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_IN_B | FL_RC_BIT}},
{24, &JitIL::reg_imm}, //"ori", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
{25, &JitIL::reg_imm}, //"oris", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
{26, &JitIL::reg_imm}, //"xori", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
{27, &JitIL::reg_imm}, //"xoris", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
{28, &JitIL::reg_imm}, //"andi_rc", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_SET_CR0}},
{29, &JitIL::reg_imm}, //"andis_rc", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_SET_CR0}},
#if JITTEST
{32, &JitIL::lXz}, //"lwz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{33, &JitIL::lXz}, //"lwzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{34, &JitIL::lXz}, //"lbz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{35, &JitIL::Default}, //"lbzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{40, &JitIL::lXz}, //"lhz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{41, &JitIL::lXz}, //"lhzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
#else
{32, &JitIL::lXz}, //"lwz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{33, &JitIL::Default}, //"lwzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{34, &JitIL::lXz}, //"lbz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{35, &JitIL::Default}, //"lbzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{40, &JitIL::lXz}, //"lhz", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{41, &JitIL::Default}, //"lhzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
#endif
{42, &JitIL::lha}, //"lha", OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
{43, &JitIL::Default}, //"lhau", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
{44, &JitIL::stX}, //"sth", OPTYPE_STORE, FL_IN_A | FL_IN_S}},
{45, &JitIL::stX}, //"sthu", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_S}},
{36, &JitIL::stX}, //"stw", OPTYPE_STORE, FL_IN_A | FL_IN_S}},
{37, &JitIL::stX}, //"stwu", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_S}},
{38, &JitIL::stX}, //"stb", OPTYPE_STORE, FL_IN_A | FL_IN_S}},
{39, &JitIL::stX}, //"stbu", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_S}},
{46, &JitIL::lmw}, //"lmw", OPTYPE_SYSTEM, FL_EVIL, 10}},
{47, &JitIL::stmw}, //"stmw", OPTYPE_SYSTEM, FL_EVIL, 10}},
{48, &JitIL::lfs}, //"lfs", OPTYPE_LOADFP, FL_IN_A}},
{49, &JitIL::Default}, //"lfsu", OPTYPE_LOADFP, FL_OUT_A | FL_IN_A}},
{50, &JitIL::lfd}, //"lfd", OPTYPE_LOADFP, FL_IN_A}},
{51, &JitIL::Default}, //"lfdu", OPTYPE_LOADFP, FL_OUT_A | FL_IN_A}},
{52, &JitIL::stfs}, //"stfs", OPTYPE_STOREFP, FL_IN_A}},
{53, &JitIL::stfs}, //"stfsu", OPTYPE_STOREFP, FL_OUT_A | FL_IN_A}},
{54, &JitIL::stfd}, //"stfd", OPTYPE_STOREFP, FL_IN_A}},
{55, &JitIL::Default}, //"stfdu", OPTYPE_STOREFP, FL_OUT_A | FL_IN_A}},
{56, &JitIL::psq_l}, //"psq_l", OPTYPE_PS, FL_IN_A}},
{57, &JitIL::psq_l}, //"psq_lu", OPTYPE_PS, FL_OUT_A | FL_IN_A}},
{60, &JitIL::psq_st}, //"psq_st", OPTYPE_PS, FL_IN_A}},
{61, &JitIL::psq_st}, //"psq_stu", OPTYPE_PS, FL_OUT_A | FL_IN_A}},
//missing: 0, 5, 6, 9, 22, 30, 62, 58
{0, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{5, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{6, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{9, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{22, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{30, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{62, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
{58, &JitIL::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
};
static GekkoOPTemplate table4[] =
{ //SUBOP10
{0, &JitIL::Default}, //"ps_cmpu0", OPTYPE_PS, FL_SET_CRn}},
{32, &JitIL::Default}, //"ps_cmpo0", OPTYPE_PS, FL_SET_CRn}},
{40, &JitIL::ps_sign}, //"ps_neg", OPTYPE_PS, FL_RC_BIT}},
{136, &JitIL::ps_sign}, //"ps_nabs", OPTYPE_PS, FL_RC_BIT}},
{264, &JitIL::ps_sign}, //"ps_abs", OPTYPE_PS, FL_RC_BIT}},
{64, &JitIL::Default}, //"ps_cmpu1", OPTYPE_PS, FL_RC_BIT}},
{72, &JitIL::ps_mr}, //"ps_mr", OPTYPE_PS, FL_RC_BIT}},
{96, &JitIL::Default}, //"ps_cmpo1", OPTYPE_PS, FL_RC_BIT}},
{528, &JitIL::ps_mergeXX}, //"ps_merge00", OPTYPE_PS, FL_RC_BIT}},
{560, &JitIL::ps_mergeXX}, //"ps_merge01", OPTYPE_PS, FL_RC_BIT}},
{592, &JitIL::ps_mergeXX}, //"ps_merge10", OPTYPE_PS, FL_RC_BIT}},
{624, &JitIL::ps_mergeXX}, //"ps_merge11", OPTYPE_PS, FL_RC_BIT}},
{1014, &JitIL::Default}, //"dcbz_l", OPTYPE_SYSTEM, 0}},
};
static GekkoOPTemplate table4_2[] =
{
{10, &JitIL::ps_sum}, //"ps_sum0", OPTYPE_PS, 0}},
{11, &JitIL::ps_sum}, //"ps_sum1", OPTYPE_PS, 0}},
{12, &JitIL::ps_muls}, //"ps_muls0", OPTYPE_PS, 0}},
{13, &JitIL::ps_muls}, //"ps_muls1", OPTYPE_PS, 0}},
{14, &JitIL::ps_maddXX}, //"ps_madds0", OPTYPE_PS, 0}},
{15, &JitIL::ps_maddXX}, //"ps_madds1", OPTYPE_PS, 0}},
{18, &JitIL::ps_arith}, //"ps_div", OPTYPE_PS, 0, 16}},
{20, &JitIL::ps_arith}, //"ps_sub", OPTYPE_PS, 0}},
{21, &JitIL::ps_arith}, //"ps_add", OPTYPE_PS, 0}},
{23, &JitIL::ps_sel}, //"ps_sel", OPTYPE_PS, 0}},
{24, &JitIL::Default}, //"ps_res", OPTYPE_PS, 0}},
{25, &JitIL::ps_arith}, //"ps_mul", OPTYPE_PS, 0}},
{26, &JitIL::ps_rsqrte}, //"ps_rsqrte", OPTYPE_PS, 0, 1}},
{28, &JitIL::ps_maddXX}, //"ps_msub", OPTYPE_PS, 0}},
{29, &JitIL::ps_maddXX}, //"ps_madd", OPTYPE_PS, 0}},
{30, &JitIL::ps_maddXX}, //"ps_nmsub", OPTYPE_PS, 0}},
{31, &JitIL::ps_maddXX}, //"ps_nmadd", OPTYPE_PS, 0}},
};
static GekkoOPTemplate table4_3[] =
{
{6, &JitIL::Default}, //"psq_lx", OPTYPE_PS, 0}},
{7, &JitIL::Default}, //"psq_stx", OPTYPE_PS, 0}},
{38, &JitIL::Default}, //"psq_lux", OPTYPE_PS, 0}},
{39, &JitIL::Default}, //"psq_stux", OPTYPE_PS, 0}},
};
static GekkoOPTemplate table19[] =
{
{528, &JitIL::bcctrx}, //"bcctrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
{16, &JitIL::bclrx}, //"bclrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
{257, &JitIL::Default}, //"crand", OPTYPE_CR, FL_EVIL}},
{129, &JitIL::Default}, //"crandc", OPTYPE_CR, FL_EVIL}},
{289, &JitIL::Default}, //"creqv", OPTYPE_CR, FL_EVIL}},
{225, &JitIL::Default}, //"crnand", OPTYPE_CR, FL_EVIL}},
{33, &JitIL::Default}, //"crnor", OPTYPE_CR, FL_EVIL}},
{449, &JitIL::Default}, //"cror", OPTYPE_CR, FL_EVIL}},
{417, &JitIL::Default}, //"crorc", OPTYPE_CR, FL_EVIL}},
{193, &JitIL::Default}, //"crxor", OPTYPE_CR, FL_EVIL}},
{150, &JitIL::DoNothing}, //"isync", OPTYPE_ICACHE, FL_EVIL}},
{0, &JitIL::Default}, //"mcrf", OPTYPE_SYSTEM, FL_EVIL}},
{50, &JitIL::rfi}, //"rfi", OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS, 1}},
{18, &JitIL::Default}, //"rfid", OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS}}
};
static GekkoOPTemplate table31[] =
{
{28, &JitIL::andx}, //"andx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{60, &JitIL::Default}, //"andcx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{444, &JitIL::orx}, //"orx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{124, &JitIL::Default}, //"norx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{316, &JitIL::xorx}, //"xorx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{412, &JitIL::Default}, //"orcx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{476, &JitIL::Default}, //"nandx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{284, &JitIL::Default}, //"eqvx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
{0, &JitIL::cmpXX}, //"cmp", OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
{32, &JitIL::cmpXX}, //"cmpl", OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
{26, &JitIL::cntlzwx}, //"cntlzwx",OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
{922, &JitIL::extshx}, //"extshx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
{954, &JitIL::extsbx}, //"extsbx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
{536, &JitIL::srwx}, //"srwx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
{792, &JitIL::srawx}, //"srawx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
{824, &JitIL::srawix}, //"srawix", OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
{24, &JitIL::slwx}, //"slwx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
{54, &JitIL::Default}, //"dcbst", OPTYPE_DCACHE, 0, 4}},
{86, &JitIL::DoNothing}, //"dcbf", OPTYPE_DCACHE, 0, 4}},
{246, &JitIL::Default}, //"dcbtst", OPTYPE_DCACHE, 0, 1}},
{278, &JitIL::Default}, //"dcbt", OPTYPE_DCACHE, 0, 1}},
{470, &JitIL::Default}, //"dcbi", OPTYPE_DCACHE, 0, 4}},
{758, &JitIL::Default}, //"dcba", OPTYPE_DCACHE, 0, 4}},
{1014, &JitIL::dcbz}, //"dcbz", OPTYPE_DCACHE, 0, 4}},
//load word
{23, &JitIL::lXzx}, //"lwzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{55, &JitIL::lXzx}, //"lwzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load halfword
{279, &JitIL::lXzx}, //"lhzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{311, &JitIL::lXzx}, //"lhzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load halfword signextend
{343, &JitIL::lhax}, //"lhax", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{375, &JitIL::Default}, //"lhaux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load byte
{87, &JitIL::lXzx}, //"lbzx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{119, &JitIL::lXzx}, //"lbzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
//load byte reverse
{534, &JitIL::Default}, //"lwbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
{790, &JitIL::Default}, //"lhbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
// Conditional load/store (Wii SMP)
{150, &JitIL::Default}, //"stwcxd", OPTYPE_STORE, FL_EVIL | FL_SET_CR0}},
{20, &JitIL::Default}, //"lwarx", OPTYPE_LOAD, FL_EVIL | FL_OUT_D | FL_IN_A0B | FL_SET_CR0}},
//load string (interpret these)
{533, &JitIL::Default}, //"lswx", OPTYPE_LOAD, FL_EVIL | FL_IN_A | FL_OUT_D}},
{597, &JitIL::Default}, //"lswi", OPTYPE_LOAD, FL_EVIL | FL_IN_AB | FL_OUT_D}},
//store word
{151, &JitIL::stXx}, //"stwx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{183, &JitIL::stXx}, //"stwux", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_B}},
//store halfword
{407, &JitIL::stXx}, //"sthx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{439, &JitIL::stXx}, //"sthux", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_B}},
//store byte
{215, &JitIL::stXx}, //"stbx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{247, &JitIL::stXx}, //"stbux", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_B}},
//store bytereverse
{662, &JitIL::Default}, //"stwbrx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
{918, &JitIL::Default}, //"sthbrx", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
{661, &JitIL::Default}, //"stswx", OPTYPE_STORE, FL_EVIL}},
{725, &JitIL::Default}, //"stswi", OPTYPE_STORE, FL_EVIL}},
// fp load/store
{535, &JitIL::lfsx}, //"lfsx", OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
{567, &JitIL::Default}, //"lfsux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
{599, &JitIL::Default}, //"lfdx", OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
{631, &JitIL::Default}, //"lfdux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
{663, &JitIL::stfsx}, //"stfsx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{695, &JitIL::Default}, //"stfsux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
{727, &JitIL::Default}, //"stfdx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{759, &JitIL::Default}, //"stfdux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
{983, &JitIL::Default}, //"stfiwx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
{19, &JitIL::mfcr}, //"mfcr", OPTYPE_SYSTEM, FL_OUT_D}},
{83, &JitIL::mfmsr}, //"mfmsr", OPTYPE_SYSTEM, FL_OUT_D}},
{144, &JitIL::mtcrf}, //"mtcrf", OPTYPE_SYSTEM, 0}},
{146, &JitIL::mtmsr}, //"mtmsr", OPTYPE_SYSTEM, FL_ENDBLOCK}},
{210, &JitIL::Default}, //"mtsr", OPTYPE_SYSTEM, 0}},
{242, &JitIL::Default}, //"mtsrin", OPTYPE_SYSTEM, 0}},
{339, &JitIL::mfspr}, //"mfspr", OPTYPE_SPR, FL_OUT_D}},
{467, &JitIL::mtspr}, //"mtspr", OPTYPE_SPR, 0, 2}},
{371, &JitIL::mftb}, //"mftb", OPTYPE_SYSTEM, FL_OUT_D | FL_TIMER}},
{512, &JitIL::Default}, //"mcrxr", OPTYPE_SYSTEM, 0}},
{595, &JitIL::Default}, //"mfsr", OPTYPE_SYSTEM, FL_OUT_D, 2}},
{659, &JitIL::Default}, //"mfsrin", OPTYPE_SYSTEM, FL_OUT_D, 2}},
{4, &JitIL::Default}, //"tw", OPTYPE_SYSTEM, 0, 1}},
{598, &JitIL::DoNothing}, //"sync", OPTYPE_SYSTEM, 0, 2}},
{982, &JitIL::icbi}, //"icbi", OPTYPE_SYSTEM, FL_ENDBLOCK, 3}},
// Unused instructions on GC
{310, &JitIL::Default}, //"eciwx", OPTYPE_INTEGER, FL_RC_BIT}},
{438, &JitIL::Default}, //"ecowx", OPTYPE_INTEGER, FL_RC_BIT}},
{854, &JitIL::Default}, //"eieio", OPTYPE_INTEGER, FL_RC_BIT}},
{306, &JitIL::Default}, //"tlbie", OPTYPE_SYSTEM, 0}},
{370, &JitIL::Default}, //"tlbia", OPTYPE_SYSTEM, 0}},
{566, &JitIL::Default}, //"tlbsync", OPTYPE_SYSTEM, 0}},
};
static GekkoOPTemplate table31_2[] =
{
{266, &JitIL::addx}, //"addx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
{10, &JitIL::Default}, //"addcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
{138, &JitIL::addex}, //"addex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{234, &JitIL::Default}, //"addmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{202, &JitIL::addzex}, //"addzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{491, &JitIL::Default}, //"divwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
{459, &JitIL::divwux}, //"divwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
{75, &JitIL::Default}, //"mulhwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
{11, &JitIL::mulhwux}, //"mulhwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
{235, &JitIL::mullwx}, //"mullwx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
{104, &JitIL::negx}, //"negx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
{40, &JitIL::subfx}, //"subfx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
{8, &JitIL::subfcx}, //"subfcx", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
{136, &JitIL::subfex}, //"subfex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{232, &JitIL::Default}, //"subfmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
{200, &JitIL::Default}, //"subfzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
};
static GekkoOPTemplate table59[] =
{
{18, &JitIL::Default}, //{"fdivsx", OPTYPE_FPU, FL_RC_BIT_F, 16}},
{20, &JitIL::fp_arith_s}, //"fsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{21, &JitIL::fp_arith_s}, //"faddsx", OPTYPE_FPU, FL_RC_BIT_F}},
// {22, &JitIL::Default}, //"fsqrtsx", OPTYPE_FPU, FL_RC_BIT_F}}, // Not implemented on gekko
{24, &JitIL::Default}, //"fresx", OPTYPE_FPU, FL_RC_BIT_F}},
{25, &JitIL::fp_arith_s}, //"fmulsx", OPTYPE_FPU, FL_RC_BIT_F}},
{28, &JitIL::fmaddXX}, //"fmsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{29, &JitIL::fmaddXX}, //"fmaddsx", OPTYPE_FPU, FL_RC_BIT_F}},
{30, &JitIL::fmaddXX}, //"fnmsubsx", OPTYPE_FPU, FL_RC_BIT_F}},
{31, &JitIL::fmaddXX}, //"fnmaddsx", OPTYPE_FPU, FL_RC_BIT_F}},
};
static GekkoOPTemplate table63[] =
{
{264, &JitIL::fsign}, //"fabsx", OPTYPE_FPU, FL_RC_BIT_F}},
{32, &JitIL::fcmpx}, //"fcmpo", OPTYPE_FPU, FL_RC_BIT_F}},
{0, &JitIL::fcmpx}, //"fcmpu", OPTYPE_FPU, FL_RC_BIT_F}},
{14, &JitIL::Default}, //"fctiwx", OPTYPE_FPU, FL_RC_BIT_F}},
{15, &JitIL::Default}, //"fctiwzx", OPTYPE_FPU, FL_RC_BIT_F}},
{72, &JitIL::fmrx}, //"fmrx", OPTYPE_FPU, FL_RC_BIT_F}},
{136, &JitIL::fsign}, //"fnabsx", OPTYPE_FPU, FL_RC_BIT_F}},
{40, &JitIL::fsign}, //"fnegx", OPTYPE_FPU, FL_RC_BIT_F}},
{12, &JitIL::Default}, //"frspx", OPTYPE_FPU, FL_RC_BIT_F}},
{64, &JitIL::Default}, //"mcrfs", OPTYPE_SYSTEMFP, 0}},
{583, &JitIL::Default}, //"mffsx", OPTYPE_SYSTEMFP, 0}},
{70, &JitIL::Default}, //"mtfsb0x", OPTYPE_SYSTEMFP, 0, 2}},
{38, &JitIL::Default}, //"mtfsb1x", OPTYPE_SYSTEMFP, 0, 2}},
{134, &JitIL::Default}, //"mtfsfix", OPTYPE_SYSTEMFP, 0, 2}},
{711, &JitIL::Default}, //"mtfsfx", OPTYPE_SYSTEMFP, 0, 2}},
};
static GekkoOPTemplate table63_2[] =
{
{18, &JitIL::Default}, //"fdivx", OPTYPE_FPU, FL_RC_BIT_F, 30}},
{20, &JitIL::Default}, //"fsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{21, &JitIL::Default}, //"faddx", OPTYPE_FPU, FL_RC_BIT_F}},
{22, &JitIL::Default}, //"fsqrtx", OPTYPE_FPU, FL_RC_BIT_F}},
{23, &JitIL::Default}, //"fselx", OPTYPE_FPU, FL_RC_BIT_F}},
{25, &JitIL::fp_arith_s}, //"fmulx", OPTYPE_FPU, FL_RC_BIT_F}},
{26, &JitIL::fp_arith_s}, //"frsqrtex", OPTYPE_FPU, FL_RC_BIT_F}},
{28, &JitIL::fmaddXX}, //"fmsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{29, &JitIL::fmaddXX}, //"fmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
{30, &JitIL::fmaddXX}, //"fnmsubx", OPTYPE_FPU, FL_RC_BIT_F}},
{31, &JitIL::fmaddXX}, //"fnmaddx", OPTYPE_FPU, FL_RC_BIT_F}},
};
namespace JitILTables
{
void CompileInstruction(UGeckoInstruction _inst)
{
JitIL *jitil = (JitIL *)jit;
(jitil->*dynaOpTable[_inst.OPCD])(_inst);
GekkoOPInfo *info = GetOpInfo(_inst);
if (info) {
#ifdef OPLOG
if (!strcmp(info->opname, OP_TO_LOG)){ ///"mcrfs"
rsplocations.push_back(jit.js.compilerPC);
}
#endif
info->compileCount++;
info->lastUse = jit->js.compilerPC;
} else {
PanicAlert("Tried to compile illegal (or unknown) instruction %08x, at %08x", _inst.hex, jit->js.compilerPC);
}
}
void InitTables()
{
//clear
for (int i = 0; i < 32; i++)
{
dynaOpTable59[i] = &JitIL::unknown_instruction;
}
for (int i = 0; i < 1024; i++)
{
dynaOpTable4 [i] = &JitIL::unknown_instruction;
dynaOpTable19[i] = &JitIL::unknown_instruction;
dynaOpTable31[i] = &JitIL::unknown_instruction;
dynaOpTable63[i] = &JitIL::unknown_instruction;
}
for (int i = 0; i < (int)(sizeof(primarytable) / sizeof(GekkoOPTemplate)); i++)
{
dynaOpTable[primarytable[i].opcode] = primarytable[i].Inst;
}
for (int i = 0; i < 32; i++)
{
int fill = i << 5;
for (int j = 0; j < (int)(sizeof(table4_2) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill+table4_2[j].opcode;
dynaOpTable4[op] = table4_2[j].Inst;
}
}
for (int i = 0; i < 16; i++)
{
int fill = i << 6;
for (int j = 0; j < (int)(sizeof(table4_3) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill+table4_3[j].opcode;
dynaOpTable4[op] = table4_3[j].Inst;
}
}
for (int i = 0; i < (int)(sizeof(table4) / sizeof(GekkoOPTemplate)); i++)
{
int op = table4[i].opcode;
dynaOpTable4[op] = table4[i].Inst;
}
for (int i = 0; i < (int)(sizeof(table31) / sizeof(GekkoOPTemplate)); i++)
{
int op = table31[i].opcode;
dynaOpTable31[op] = table31[i].Inst;
}
for (int i = 0; i < 1; i++)
{
int fill = i << 9;
for (int j = 0; j < (int)(sizeof(table31_2) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill + table31_2[j].opcode;
dynaOpTable31[op] = table31_2[j].Inst;
}
}
for (int i = 0; i < (int)(sizeof(table19) / sizeof(GekkoOPTemplate)); i++)
{
int op = table19[i].opcode;
dynaOpTable19[op] = table19[i].Inst;
}
for (int i = 0; i < (int)(sizeof(table59) / sizeof(GekkoOPTemplate)); i++)
{
int op = table59[i].opcode;
dynaOpTable59[op] = table59[i].Inst;
}
for (int i = 0; i < (int)(sizeof(table63) / sizeof(GekkoOPTemplate)); i++)
{
int op = table63[i].opcode;
dynaOpTable63[op] = table63[i].Inst;
}
for (int i = 0; i < 32; i++)
{
int fill = i << 5;
for (int j = 0; j < (int)(sizeof(table63_2) / sizeof(GekkoOPTemplate)); j++)
{
int op = fill + table63_2[j].opcode;
dynaOpTable63[op] = table63_2[j].Inst;
}
}
}
}

View File

@ -0,0 +1,31 @@
// 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.
// 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 JITIL_TABLES_H
#define JITIL_TABLES_H
#include "../Gekko.h"
#include "../PPCTables.h"
#include "../Jit64IL/JitIL.h"
namespace JitILTables
{
void CompileInstruction(UGeckoInstruction _inst);
void InitTables();
}
#endif

View File

@ -31,6 +31,26 @@ public:
void GenFifoXmm64Write();
void GenFifoFloatWrite();
const u8 *fifoDirectWrite8;
const u8 *fifoDirectWrite16;
const u8 *fifoDirectWrite32;
const u8 *fifoDirectWriteFloat;
const u8 *fifoDirectWriteXmm64;
const u8 *enterCode;
const u8 *dispatcher;
const u8 *dispatcherNoCheck;
const u8 *dispatcherPcInEAX;
const u8 *fpException;
const u8 *computeRc;
const u8 *testExceptions;
const u8 *dispatchPcInEAX;
const u8 *doTiming;
const u8 *breakpointBailout;
// In: array index: GQR to use.
// In: ECX: Address to read from.
// Out: XMM0: Bottom two 32-bit slots hold the read value,

View File

@ -19,13 +19,9 @@
#include "Common.h"
#include "disasm.h"
#ifdef JITTEST
#include "../Jit64IL/Jit.h"
#include "../Jit64IL/JitAsm.h"
#else
#include "../Jit64/Jit.h"
#include "../Jit64/JitAsm.h"
#endif
#include "../JitCommon/JitBase.h"
#include "../JitCommon/JitBackpatch.h"
#include "../../HW/Memmap.h"
#include "x64Emitter.h"
@ -34,6 +30,27 @@
#include "x64Analyzer.h"
#include "StringUtil.h"
#ifdef _WIN32
#include <windows.h>
#endif
#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
using namespace Gen;
@ -118,7 +135,7 @@ const u8 *TrampolineCache::GetWriteTrampoline(const InstructionInfo &info)
CMP(32, R(addrReg), Imm32(0xCC008000));
FixupBranch skip_fast = J_CC(CC_NE, false);
MOV(32, R(ABI_PARAM1), R((X64Reg)dataReg));
CALL((void*)asm_routines.fifoDirectWrite32);
CALL((void*)jit->GetAsmRoutines()->fifoDirectWrite32);
RET();
SetJumpTarget(skip_fast);
ABI_PushAllCallerSavedRegsAndAdjustStack();
@ -149,10 +166,12 @@ const u8 *TrampolineCache::GetWriteTrampoline(const InstructionInfo &info)
// 1) It's really necessary. We don't know anything about the context.
// 2) It doesn't really hurt. Only instructions that access I/O will get these, and there won't be
// that many of them in a typical program/game.
const u8 *Jit64::BackPatch(u8 *codePtr, int accessType, u32 emAddress, CONTEXT *ctx)
const u8 *JitBase::BackPatch(u8 *codePtr, int accessType, u32 emAddress, void *ctx_void)
{
CONTEXT *ctx = (CONTEXT *)ctx_void;
#ifdef _M_X64
if (!jit.IsInCodeSpace(codePtr))
if (!jit->IsInCodeSpace(codePtr))
return 0; // this will become a regular crash real soon after this
InstructionInfo info;

View File

@ -0,0 +1,41 @@
// 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.
// 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 _JITBACKPATCH_H
#define _JITBACKPATCH_H
#include "Common.h"
#include "x64Emitter.h"
#include "x64Analyzer.h"
// Declarations and definitions
// ----------
// void Jit(u32 em_address);
class TrampolineCache : public Gen::XCodeBlock
{
public:
void Init();
void Shutdown();
const u8 *GetReadTrampoline(const InstructionInfo &info);
const u8 *GetWriteTrampoline(const InstructionInfo &info);
};
#endif

View File

@ -0,0 +1,102 @@
// Copyright (C) 2010 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 _JITBASE_H
#define _JITBASE_H
#include "JitCache.h"
#include "Jit_Util.h" // for EmuCodeBlock
#include "JitBackpatch.h" // for EmuCodeBlock
#include "JitAsmCommon.h"
#define JIT_OPCODE 0
// TODO: In the future, inherit this from CPUCoreBase and have Interpreter
// inherit from that too?
class JitBase : public EmuCodeBlock
{
protected:
JitBlockCache blocks;
TrampolineCache trampolines;
struct JitOptions
{
bool optimizeStack;
bool assumeFPLoadFromMem;
bool enableBlocklink;
bool fpAccurateFcmp;
bool enableFastMem;
bool optimizeGatherPipe;
bool fastInterrupts;
bool accurateSinglePrecision;
};
struct JitState
{
u32 compilerPC;
u32 next_compilerPC;
u32 blockStart;
bool cancel;
UGeckoInstruction next_inst; // for easy peephole opt.
int blockSize;
int instructionNumber;
int downcountAmount;
bool isLastInstruction;
bool forceUnsafeLoad;
int fifoBytesThisBlock;
PPCAnalyst::BlockStats st;
PPCAnalyst::BlockRegStats gpa;
PPCAnalyst::BlockRegStats fpa;
PPCAnalyst::CodeOp *op;
u8* rewriteStart;
JitBlock *curBlock;
};
public:
// This should probably be removed from public:
JitOptions jo;
JitState js;
JitBlockCache *GetBlockCache() { return &blocks; }
virtual void Init() = 0;
virtual void Shutdown() = 0;
virtual void Jit(u32 em_address) = 0;
virtual void ClearCache() = 0;
virtual void Run() = 0;
virtual void SingleStep() = 0;
virtual void NotifyBreakpoint(u32 em_address, bool set) = 0;
const u8 *BackPatch(u8 *codePtr, int accessType, u32 em_address, void *ctx);
virtual const CommonAsmRoutines *GetAsmRoutines() = 0;
virtual const char *GetName() = 0;
};
extern JitBase *jit;
void Jit(u32 em_address);
// Merged routines that should be moved somewhere better
u32 Helper_Mask(u8 mb, u8 me);
#endif

View File

@ -23,6 +23,11 @@
// locating performance issues.
#include "Common.h"
#ifdef _WIN32
#include <windows.h>
#endif
#include "../../Core.h"
#include "MemoryUtil.h"
@ -36,15 +41,8 @@
#include "x64Emitter.h"
#include "x64Analyzer.h"
#ifdef JITTEST
#include "../Jit64IL/Jit.h"
#include "../Jit64IL/JitAsm.h"
#else
#include "../Jit64/Jit.h"
#include "../Jit64/JitAsm.h"
#endif
#include "JitCache.h"
#include "JitBase.h"
#include "disasm.h"
@ -378,7 +376,7 @@ bool JitBlock::ContainsAddress(u32 em_address)
// Spurious entrances from previously linked blocks can only come through checkedEntry
XEmitter emit((u8 *)b.checkedEntry);
emit.MOV(32, M(&PC), Imm32(b.originalAddress));
emit.JMP(asm_routines.dispatcher, true);
emit.JMP(jit->GetAsmRoutines()->dispatcher, true);
// this is not needed really
/*
emit.SetCodePtr((u8 *)blockCodePointers[blocknum]);

View File

@ -24,9 +24,6 @@
#include "../Gekko.h"
#include "../PPCAnalyst.h"
#ifdef _WIN32
#include <windows.h>
#endif
// emulate CPU with unlimited instruction cache
// the only way to invalidate a region is the "icbi" instruction
@ -59,9 +56,9 @@ struct JitBlock
#ifdef _WIN32
// we don't really need to save start and stop
// TODO (mb2): ticStart and ticStop -> "local var" mean "in block" ... low priority ;)
LARGE_INTEGER ticStart; // for profiling - time.
LARGE_INTEGER ticStop; // for profiling - time.
LARGE_INTEGER ticCounter; // for profiling - time.
u64 ticStart; // for profiling - time.
u64 ticStop; // for profiling - time.
u64 ticCounter; // for profiling - time.
#endif
const u8 *checkedEntry;
const u8 *normalEntry;
@ -92,8 +89,9 @@ class JitBlockCache
void LinkBlock(int i);
public:
JitBlockCache() {}
JitBlockCache() :
blockCodePointers(0), blocks(0), num_blocks(0),
iCache(0), iCacheEx(0), iCacheVMEM(0), MAX_NUM_BLOCKS(0) { }
int AllocateBlock(u32 em_address);
void FinalizeBlock(int block_num, bool block_link, const u8 *code_ptr);

View File

@ -26,17 +26,8 @@
#include "../PPCTables.h"
#include "x64Emitter.h"
#include "ABI.h"
#ifdef JITTEST
#include "../Jit64IL/Jit.h"
#include "JitCache.h"
#include "../Jit64IL/JitAsm.h"
#else
#include "../Jit64/Jit.h"
#include "JitCache.h"
#include "../Jit64/JitAsm.h"
#include "../Jit64/JitRegCache.h"
#endif
#include "JitBase.h"
#include "Jit_Util.h"
using namespace Gen;
@ -191,7 +182,7 @@ void EmuCodeBlock::WriteFloatToConstRamAddress(const Gen::X64Reg& xmm_reg, u32 a
void EmuCodeBlock::ForceSinglePrecisionS(X64Reg xmm) {
// Most games don't need these. Zelda requires it though - some platforms get stuck without them.
if (jit.jo.accurateSinglePrecision)
if (jit->jo.accurateSinglePrecision)
{
CVTSD2SS(xmm, R(xmm));
CVTSS2SD(xmm, R(xmm));
@ -200,7 +191,7 @@ void EmuCodeBlock::ForceSinglePrecisionS(X64Reg xmm) {
void EmuCodeBlock::ForceSinglePrecisionP(X64Reg xmm) {
// Most games don't need these. Zelda requires it though - some platforms get stuck without them.
if (jit.jo.accurateSinglePrecision)
if (jit->jo.accurateSinglePrecision)
{
CVTPD2PS(xmm, R(xmm));
CVTPS2PD(xmm, R(xmm));

View File

@ -24,13 +24,11 @@
#include "Interpreter/Interpreter.h"
#include "Interpreter/Interpreter_Tables.h"
#if !(defined(NOJIT) && NOJIT)
#include "JitCommon/Jit_Tables.h"
#include "Jit64IL/JitIL_Tables.h"
#include "Jit64/Jit64_Tables.h"
#if defined(_M_IX86) || defined(_M_X64)
#include "Jit64IL/JitIL.h"
#include "Jit64/Jit.h"
#else
#error Unknown architecture!
#endif
#endif
struct op_inf
@ -156,13 +154,15 @@ bool UsesFPU(UGeckoInstruction _inst)
return false;
}
}
void InitTables()
{
// Interpreter ALWAYS needs to be initialized
InterpreterTables::InitTables();
#if !(defined(NOJIT) && NOJIT)
// Should be able to do this a better way than defines in this function
JitTables::InitTables();
Jit64Tables::InitTables();
JitILTables::InitTables();
#endif
}

View File

@ -27,6 +27,8 @@
#include "../CoreTiming.h"
#include "Interpreter/Interpreter.h"
#include "JitCommon/JitBase.h"
#include "Jit64IL/JitIL.h"
#include "Jit64/Jit.h"
#include "PowerPC.h"
#include "PPCTables.h"
@ -109,7 +111,7 @@ void ResetRegisters()
rDEC = 0xFFFFFFFF;
}
void Init()
void Init(int cpu_core)
{
enum {
FPU_PREC_24 = 0 << 8,
@ -139,7 +141,12 @@ void Init()
// Initialize both execution engines ...
Interpreter::Init();
jit.Init();
if (cpu_core == 1)
jit = new Jit64;
else
jit = new JitIL;
jit->Init();
// ... but start as interpreter by default.
mode = MODE_INTERPRETER;
state = CPU_STEPPING;
@ -150,7 +157,9 @@ void Init()
void Shutdown()
{
// Shutdown both execution engines. Doesn't matter which one is active.
jit.Shutdown();
jit->Shutdown();
delete jit;
jit = 0;
Interpreter::Shutdown();
}
@ -163,7 +172,7 @@ void SetMode(CoreMode new_mode)
switch (mode)
{
case MODE_INTERPRETER: // Switching from JIT to interpreter
jit.ClearCache(); // Remove all those nasty JIT patches.
jit->ClearCache(); // Remove all those nasty JIT patches.
break;
case MODE_JIT: // Switching from interpreter to JIT.
@ -180,7 +189,7 @@ void SingleStep()
Interpreter::SingleStep();
break;
case MODE_JIT:
jit.SingleStep();
jit->SingleStep();
break;
}
}
@ -194,7 +203,7 @@ void RunLoop()
Interpreter::Run();
break;
case MODE_JIT:
jit.Run();
jit->Run();
break;
}
Host_UpdateDisasmDialog();

View File

@ -88,7 +88,7 @@ extern BreakPoints breakpoints;
extern MemChecks memchecks;
extern PPCDebugInterface debug_interface;
void Init();
void Init(int cpu_core);
void Shutdown();
void DoState(PointerWrap &p);

View File

@ -15,11 +15,15 @@
// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/
#include "Jit64/Jit.h"
#include "JitCommon/JitBase.h"
#include <vector>
#include <algorithm>
#ifdef _WIN32
#include <windows.h>
#endif
#include "PPCSymbolDB.h"
namespace Profiler
@ -41,19 +45,19 @@ struct BlockStat
void WriteProfileResults(const char *filename) {
std::vector<BlockStat> stats;
stats.reserve(jit.GetBlockCache()->GetNumBlocks());
stats.reserve(jit->GetBlockCache()->GetNumBlocks());
u64 cost_sum = 0;
#ifdef _WIN32
u64 timecost_sum = 0;
LARGE_INTEGER countsPerSec;
QueryPerformanceFrequency(&countsPerSec);
u64 countsPerSec;
QueryPerformanceFrequency((LARGE_INTEGER *)&countsPerSec);
#endif
for (int i = 0; i < jit.GetBlockCache()->GetNumBlocks(); i++)
for (int i = 0; i < jit->GetBlockCache()->GetNumBlocks(); i++)
{
const JitBlock *block = jit.GetBlockCache()->GetBlock(i);
const JitBlock *block = jit->GetBlockCache()->GetBlock(i);
u64 cost = (block->originalSize / 4) * block->runCount; // rough heuristic. mem instructions should cost more.
#ifdef _WIN32
u64 timecost = block->ticCounter.QuadPart; // Indeed ;)
u64 timecost = block->ticCounter; // Indeed ;)
#endif
if (block->runCount >= 1) { // Todo: tweak.
stats.push_back(BlockStat(i, cost));
@ -73,15 +77,15 @@ void WriteProfileResults(const char *filename) {
fprintf(f, "origAddr\tblkName\tcost\ttimeCost\tpercent\ttimePercent\tOvAllinBlkTime(ms)\tblkCodeSize\n");
for (unsigned int i = 0; i < stats.size(); i++)
{
const JitBlock *block = jit.GetBlockCache()->GetBlock(stats[i].blockNum);
const JitBlock *block = jit->GetBlockCache()->GetBlock(stats[i].blockNum);
if (block)
{
std::string name = g_symbolDB.GetDescription(block->originalAddress);
double percent = 100.0 * (double)stats[i].cost / (double)cost_sum;
#ifdef _WIN32
double timePercent = 100.0 * (double)block->ticCounter.QuadPart / (double)timecost_sum;
double timePercent = 100.0 * (double)block->ticCounter / (double)timecost_sum;
fprintf(f, "%08x\t%s\t%llu\t%llu\t%.2lf\t%llf\t%lf\t%i\n",
block->originalAddress, name.c_str(), stats[i].cost, block->ticCounter.QuadPart, percent, timePercent, (double)block->ticCounter.QuadPart*1000.0/(double)countsPerSec.QuadPart, block->codeSize);
block->originalAddress, name.c_str(), stats[i].cost, block->ticCounter, percent, timePercent, (double)block->ticCounter*1000.0/(double)countsPerSec, block->codeSize);
#else
fprintf(f, "%08x\t%s\t%llu\t???\t%.2lf\t???\t???\t%i\n",
block->originalAddress, name.c_str(), stats[i].cost, /*block->ticCounter.QuadPart,*/ percent, /*timePercent, (double)block->ticCounter.QuadPart*1000.0/(double)countsPerSec.QuadPart,*/ block->codeSize);

View File

@ -28,15 +28,15 @@
// TODO: r64 way
// asm write : (u64) dt += t1-t0
#define PROFILER_ADD_DIFF_LARGE_INTEGER(pdt, pt1, pt0) \
MOV(32, R(EAX), M(pt1.LowPart)); \
SUB(32, R(EAX), M(pt0.LowPart)); \
MOV(32, R(ECX), M(pt1.HighPart)); \
SBB(32, R(ECX), M(pt0.HighPart)); \
ADD(32, R(EAX), M(pdt.LowPart)); \
MOV(32, R(EDX), M(pdt.HighPart)); \
MOV(32, R(EAX), M(pt1)); \
SUB(32, R(EAX), M(pt0)); \
MOV(32, R(ECX), M(((u8*)pt1) + 4)); \
SBB(32, R(ECX), M(((u8*)pt0) + 4)); \
ADD(32, R(EAX), M(pdt)); \
MOV(32, R(EDX), M(((u8*)pdt) + 4)); \
ADC(32, R(EDX), R(ECX)); \
MOV(32, M(pdt.LowPart), R(EAX)); \
MOV(32, M(pdt.HighPart), R(EDX))
MOV(32, M(pdt), R(EAX)); \
MOV(32, M(((u8*)pdt) + 4), R(EDX))
#define PROFILER_VPUSH PUSH(EAX);PUSH(ECX);PUSH(EDX)
#define PROFILER_VPOP POP(EDX);POP(ECX);POP(EAX)

View File

@ -90,13 +90,13 @@ files = ["ActionReplay.cpp",
"PowerPC/JitCommon/JitAsmCommon.cpp",
"PowerPC/JitCommon/JitCache.cpp",
"PowerPC/JitCommon/JitBackpatch.cpp",
"PowerPC/JitCommon/JitBase.cpp",
"PowerPC/JitCommon/Jit_Util.cpp",
"HLE/HLE.cpp",
"HLE/HLE_Misc.cpp",
"HLE/HLE_OS.cpp",
]
if not env['NOJIT']:
if env['JITTEST']:
files += ["PowerPC/Jit64IL/Jit.cpp",
"PowerPC/Jit64IL/JitAsm.cpp",
"PowerPC/Jit64IL/Jit_Branch.cpp",
@ -109,9 +109,8 @@ if not env['NOJIT']:
"PowerPC/Jit64IL/Jit_SystemRegisters.cpp",
"PowerPC/Jit64IL/IR.cpp",
"PowerPC/Jit64IL/IR_X86.cpp",
"PowerPC/JitCommon//Jit_Tables.cpp",
"PowerPC/Jit64IL/JitIL_Tables.cpp",
]
else:
files += ["PowerPC/Jit64/Jit.cpp",
"PowerPC/Jit64/JitRegCache.cpp",
"PowerPC/Jit64/JitAsm.cpp",
@ -123,7 +122,7 @@ if not env['NOJIT']:
"PowerPC/Jit64/Jit_LoadStore.cpp",
"PowerPC/Jit64/Jit_LoadStoreFloating.cpp",
"PowerPC/Jit64/Jit_SystemRegisters.cpp",
"PowerPC/JitCommon/Jit_Tables.cpp",
"PowerPC/Jit64/Jit64_Tables.cpp",
]
if sys.platform == 'win32':

View File

@ -24,11 +24,7 @@
#include "CoreTiming.h"
#include "HW/HW.h"
#include "PowerPC/PowerPC.h"
#ifdef JITTEST
#include "PowerPC/Jit64IL/Jit.h"
#else
#include "PowerPC/Jit64/Jit.h"
#endif
#include "PowerPC/JitCommon/JitBase.h"
#include "PluginManager.h"
@ -97,9 +93,9 @@ void DoState(PointerWrap &p)
HW::DoState(p);
CoreTiming::DoState(p);
#ifdef JIT_UNLIMITED_ICACHE
p.DoVoid(jit.GetBlockCache()->GetICache(), JIT_ICACHE_SIZE);
p.DoVoid(jit.GetBlockCache()->GetICacheEx(), JIT_ICACHEEX_SIZE);
p.DoVoid(jit.GetBlockCache()->GetICacheVMEM(), JIT_ICACHE_SIZE);
p.DoVoid(jit->GetBlockCache()->GetICache(), JIT_ICACHE_SIZE);
p.DoVoid(jit->GetBlockCache()->GetICacheEx(), JIT_ICACHEEX_SIZE);
p.DoVoid(jit->GetBlockCache()->GetICacheVMEM(), JIT_ICACHE_SIZE);
#endif
}
@ -110,7 +106,7 @@ void LoadBufferStateCallback(u64 userdata, int cyclesLate)
return;
}
jit.ClearCache();
jit->ClearCache();
u8 *ptr = *cur_buffer;
PointerWrap p(&ptr, PointerWrap::MODE_READ);
@ -129,7 +125,7 @@ void SaveBufferStateCallback(u64 userdata, int cyclesLate)
return;
}
jit.ClearCache();
jit->ClearCache();
u8 *ptr = NULL;
@ -228,7 +224,7 @@ void SaveStateCallback(u64 userdata, int cyclesLate)
saveThread = NULL;
}
jit.ClearCache();
jit->ClearCache();
// Measure the size of the buffer.
u8 *ptr = 0;
@ -340,7 +336,7 @@ void LoadStateCallback(u64 userdata, int cyclesLate)
fclose(f);
jit.ClearCache();
jit->ClearCache();
u8 *ptr = buffer;
PointerWrap p(&ptr, PointerWrap::MODE_READ);

View File

@ -54,7 +54,7 @@
#include "PowerPC/PPCSymbolDB.h"
#include "PowerPC/SignatureDB.h"
#include "PowerPC/PPCTables.h"
#include "PowerPC/Jit64/Jit.h"
#include "PowerPC/JitCommon/JitBase.h"
#include "PowerPC/JitCommon/JitCache.h" // for ClearCache()
#include "PluginManager.h"
@ -435,7 +435,7 @@ void CCodeWindow::CreateMenu(const SCoreStartupParameter& _LocalCoreStartupParam
" and stepping to work as explained in the Developer Documentation. But it can be very"
" slow, perhaps slower than 1 fps.")
, wxITEM_CHECK);
interpreter->Check(!_LocalCoreStartupParameter.bUseJIT);
interpreter->Check(_LocalCoreStartupParameter.iCPUCore == 0);
pCoreMenu->AppendSeparator();
jitblocklinking = pCoreMenu->Append(IDM_JITBLOCKLINKING, _T("&JIT Block Linking off"),
@ -551,7 +551,7 @@ void CCodeWindow::OnCPUMode(wxCommandEvent& event)
}
// Clear the JIT cache to enable these changes
jit.ClearCache();
jit->ClearCache();
// Update
UpdateButtonStates();
}
@ -563,7 +563,7 @@ void CCodeWindow::OnJitMenu(wxCommandEvent& event)
PPCTables::LogCompiledInstructions(); break;
case IDM_CLEARCODECACHE:
jit.ClearCache(); break;
jit->ClearCache(); break;
case IDM_SEARCHINSTRUCTION:
{

View File

@ -61,7 +61,7 @@
#include "PowerPC/PPCSymbolDB.h"
#include "PowerPC/SignatureDB.h"
#include "PowerPC/PPCTables.h"
#include "PowerPC/Jit64/Jit.h"
#include "PowerPC/JitCommon/JitBase.h"
#include "PowerPC/JitCommon/JitCache.h" // for ClearCache()
#include "PluginManager.h"
@ -221,7 +221,7 @@ void CCodeWindow::OnProfilerMenu(wxCommandEvent& event)
switch (event.GetId())
{
case IDM_PROFILEBLOCKS:
jit.ClearCache();
jit->ClearCache();
Profiler::g_ProfileBlocks = GetMenuBar()->IsChecked(IDM_PROFILEBLOCKS);
break;
case IDM_WRITEPROFILE:

View File

@ -27,11 +27,7 @@
#include "JitWindow.h"
#include "HW/CPU.h"
#include "PowerPC/PowerPC.h"
#if JITTEST
#include "PowerPC/Jit64/Jit.h"
#else
#include "PowerPC/Jit64IL/Jit.h"
#endif
#include "PowerPC/JitCommon/JitBase.h"
#include "PowerPC/JitCommon/JitCache.h"
#include "PowerPC/PPCAnalyst.h"
#include "PowerPCDisasm.h"
@ -130,16 +126,16 @@ void CJitWindow::Compare(u32 em_address)
disassembler x64disasm;
x64disasm.set_syntax_intel();
int block_num = jit.GetBlockCache()->GetBlockNumberFromStartAddress(em_address);
int block_num = jit->GetBlockCache()->GetBlockNumberFromStartAddress(em_address);
if (block_num < 0)
{
for (int i = 0; i < 500; i++) {
block_num = jit.GetBlockCache()->GetBlockNumberFromStartAddress(em_address - 4 * i);
block_num = jit->GetBlockCache()->GetBlockNumberFromStartAddress(em_address - 4 * i);
if (block_num >= 0)
break;
}
if (block_num >= 0) {
JitBlock *block = jit.GetBlockCache()->GetBlock(block_num);
JitBlock *block = jit->GetBlockCache()->GetBlock(block_num);
if (!(block->originalAddress <= em_address && block->originalSize + block->originalAddress >= em_address))
block_num = -1;
}
@ -150,12 +146,12 @@ void CJitWindow::Compare(u32 em_address)
return;
}
}
JitBlock *block = jit.GetBlockCache()->GetBlock(block_num);
JitBlock *block = jit->GetBlockCache()->GetBlock(block_num);
// 800031f0
// == Fill in x86 box
const u8 *code = (const u8 *)jit.GetBlockCache()->GetCompiledCodeFromBlock(block_num);
const u8 *code = (const u8 *)jit->GetBlockCache()->GetCompiledCodeFromBlock(block_num);
u64 disasmPtr = (u64)code;
int size = block->codeSize;
const u8 *end = code + size;

View File

@ -700,122 +700,6 @@
ExcludedFromBuild="false"
/>
</Configuration>
<Configuration
Name="Release_JITIL|Win32"
OutputDirectory="$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="1"
>
<Tool
Name="VCPreBuildEventTool"
CommandLine="&quot;$(ProjectDir)..\Common\SubWCRev.exe&quot; &quot;$(SolutionDir)\.&quot; &quot;$(ProjectDir)..\Common\src\svnrev_template.h&quot; &quot;$(ProjectDir)..\Common\src\svnrev.h&quot;"
ExcludedFromBuild="false"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
PreprocessorDefinitions="WIN32,__WXMSW__,_WINDOWS,NOPCH"
MkTypLibCompatible="true"
SuppressStartupBanner="true"
TargetEnvironment="1"
TypeLibraryName=".\vc_msw/toolbar.tlb"
HeaderFileName=""
/>
<Tool
Name="VCCLCompilerTool"
Optimization="3"
InlineFunctionExpansion="0"
FavorSizeOrSpeed="1"
AdditionalIncludeDirectories="..\Common\Src;..\Core\Src;..\DebuggerWX\src;..\DebuggerUICommon\src;..\DiscIO\Src;..\InputCommon\Src;..\..\PluginSpecs;..\..\..\Externals\wxWidgets\Include;..\..\..\Externals\wxWidgets\Include\msvc;..\..\..\Externals\SFML\include"
PreprocessorDefinitions="WIN32;__WXMSW__;_WINDOWS;NOPCH;_SECURE_SCL=0;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE"
StringPooling="false"
RuntimeLibrary="0"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="false"
EnableEnhancedInstructionSet="2"
FloatingPointModel="0"
RuntimeTypeInfo="false"
UsePrecompiledHeader="2"
PrecompiledHeaderFile="$(IntDir)\$(TargetName).pch"
AssemblerListingLocation="$(IntDir)\"
ObjectFile="$(IntDir)\"
ProgramDataBaseFileName="$(IntDir)\vc80.pdb"
WarningLevel="4"
WarnAsError="false"
SuppressStartupBanner="true"
DebugInformationFormat="3"
ForcedIncludeFiles="stdafx.h"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="__WXMSW__,_WINDOWS,NOPCH"
Culture="1033"
AdditionalIncludeDirectories=".\..\..\lib\vc_lib\msw;.\..\..\include;.;.\..\..\samples"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="comctl32.lib rpcrt4.lib winmm.lib wxbase28u.lib wxmsw28u_core.lib wxmsw28u_adv.lib wxmsw28u_aui.lib Bochs_disasm.lib LZO.lib SFML_Network.lib zlib.lib"
OutputFile="../../../Binary/Win32/DolphinIL.exe"
LinkIncremental="1"
SuppressStartupBanner="true"
AdditionalLibraryDirectories="&quot;$(SolutionDir)\Release\$(PlatformName)&quot;;&quot;..\..\..\Externals\wxWidgets\lib\vc_lib\$(PlatformName)&quot;"
IgnoreAllDefaultLibraries="false"
IgnoreDefaultLibraryNames=""
GenerateDebugInformation="true"
ProgramDatabaseFile="$(PlatformName)\$(ConfigurationName)\$(TargetName).pdb"
GenerateMapFile="false"
MapFileName="$(TargetDir)linkermap.map"
SubSystem="2"
BaseAddress="0x00400000"
RandomizedBaseAddress="1"
DataExecutionPrevention="2"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
SuppressStartupBanner="true"
OutputFile=".\vc_msw/toolbar.bsc"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
Description="Copying Data\* to $(TargetDir)"
CommandLine="xcopy &quot;$(SolutionDir)..\Data&quot; &quot;$(TargetDir)&quot; /e /s /y /d&#x0D;&#x0A;echo Copying External .dlls&#x0D;&#x0A;xcopy &quot;$(SolutionDir)..\Externals\Cg\*.dll&quot; &quot;$(TargetDir)&quot; /e /s /y /q /d&#x0D;&#x0A;xcopy &quot;$(SolutionDir)..\Externals\SDL\win32\*.dll&quot; &quot;$(TargetDir)&quot; /e /s /y /q /d&#x0D;&#x0A;xcopy &quot;$(SolutionDir)..\Externals\WiiUse\Win32\*.dll&quot; &quot;$(TargetDir)&quot; /e /s /y /q /d&#x0D;&#x0A;"
ExcludedFromBuild="false"
/>
</Configuration>
<Configuration
Name="Release_JITIL|x64"
OutputDirectory="$(PlatformName)\$(ConfigurationName)"
@ -1205,15 +1089,6 @@
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="0"
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
>
@ -1281,15 +1156,6 @@
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="0"
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
>
@ -1357,15 +1223,6 @@
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="0"
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
>
@ -1441,15 +1298,6 @@
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="0"
ForcedIncludeFiles="$(NOINHERIT)"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
>
@ -1495,14 +1343,6 @@
WarnAsError="false"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
>
<Tool
Name="VCCLCompilerTool"
WarnAsError="false"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\src\MemoryCards\GCMemcard.h"
@ -1601,14 +1441,6 @@
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
ExcludedFromBuild="true"
@ -1677,14 +1509,6 @@
UsePrecompiledHeader="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|Win32"
>
<Tool
Name="VCCLCompilerTool"
UsePrecompiledHeader="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
>

View File

@ -82,7 +82,7 @@ bool BootCore(const std::string& _rFilename)
if (main_frame->g_pCodeWindow)
{
//StartUp.bCPUThread = code_frame->UseDualCore();
StartUp.bUseJIT = !main_frame->g_pCodeWindow->UseInterpreter();
StartUp.iCPUCore = !main_frame->g_pCodeWindow->UseInterpreter();
StartUp.bBootToPause = main_frame->g_pCodeWindow->BootToPause();
StartUp.bAutomaticStart = main_frame->g_pCodeWindow->AutomaticStart();
StartUp.bJITUnlimitedCache = main_frame->g_pCodeWindow->UnlimitedJITCache();

View File

@ -29,7 +29,6 @@
#include "SysConf.h"
#include "Frame.h"
extern CFrame* main_frame;
// Strings for Device Selections
@ -45,7 +44,6 @@ extern CFrame* main_frame;
#define EXIDEV_BBA_STR "BBA"
#define EXIDEV_AM_BB_STR "AM-Baseboard"
BEGIN_EVENT_TABLE(CConfigMain, wxDialog)
EVT_CLOSE(CConfigMain::OnClose)
@ -62,6 +60,7 @@ EVT_CHOICE(ID_INTERFACE_LANG, CConfigMain::CoreSettingsChanged)
EVT_CHECKBOX(ID_ALWAYS_HLE_BS2, CConfigMain::CoreSettingsChanged)
EVT_RADIOBUTTON(ID_RADIOJIT, CConfigMain::CoreSettingsChanged)
EVT_RADIOBUTTON(ID_RADIOJITIL, CConfigMain::CoreSettingsChanged)
EVT_RADIOBUTTON(ID_RADIOINT, CConfigMain::CoreSettingsChanged)
EVT_CHECKBOX(ID_CPUTHREAD, CConfigMain::CoreSettingsChanged)
EVT_CHECKBOX(ID_DSPTHREAD, CConfigMain::CoreSettingsChanged)
@ -128,7 +127,6 @@ CConfigMain::~CConfigMain()
{
}
// Used to restrict changing of some options while emulator is running
void CConfigMain::UpdateGUI()
{
@ -183,7 +181,7 @@ void CConfigMain::CreateGUIControls()
// Framelimit
arrayStringFor_Framelimit.Add(wxT("Off"));
arrayStringFor_Framelimit.Add(wxT("Auto"));
for (int i = 20; i <= 120; i+=10) // from 20 to 120
for (int i = 20; i <= 120; i += 10) // from 20 to 120
arrayStringFor_Framelimit.Add(wxString::Format(wxT("%i"), i));
// Create the notebook and pages
@ -200,8 +198,6 @@ void CConfigMain::CreateGUIControls()
Notebook->AddPage(PathsPage, wxT("Paths"));
Notebook->AddPage(PluginPage, wxT("Plugins"));
// General page
// Core Settings - Basic
@ -222,9 +218,14 @@ void CConfigMain::CreateGUIControls()
//
AlwaysHLE_BS2 = new wxCheckBox(GeneralPage, ID_ALWAYS_HLE_BS2, wxT("HLE the IPL (recommended)"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
AlwaysHLE_BS2->SetValue(SConfig::GetInstance().m_LocalCoreStartupParameter.bHLE_BS2);
m_RadioJIT = new wxRadioButton(GeneralPage, ID_RADIOJIT, wxT("JIT Recompiler (recommended)"));
m_RadioInt = new wxRadioButton(GeneralPage, ID_RADIOINT, wxT("Interpreter (very slow)"));
SConfig::GetInstance().m_LocalCoreStartupParameter.bUseJIT ? m_RadioJIT->SetValue(true) : m_RadioInt->SetValue(true);
m_RadioJIT = new wxRadioButton(GeneralPage, ID_RADIOJIT, wxT("JIT recompiler (recommended)"));
m_RadioJITIL = new wxRadioButton(GeneralPage, ID_RADIOJITIL, wxT("JitIL experimental recompiler"));
m_RadioInt = new wxRadioButton(GeneralPage, ID_RADIOINT, wxT("Interpreter (VERY slow)"));
switch (SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore) {
case 0: m_RadioInt->SetValue(true); break;
case 1: m_RadioJIT->SetValue(true); break;
case 2: m_RadioJITIL->SetValue(true); break;
}
LockThreads = new wxCheckBox(GeneralPage, ID_LOCKTHREADS, wxT("Lock threads to cores"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
LockThreads->SetValue(SConfig::GetInstance().m_LocalCoreStartupParameter.bLockThreads);
DSPThread = new wxCheckBox(GeneralPage, ID_DSPTHREAD, wxT("DSP on thread (recommended)"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
@ -310,6 +311,7 @@ void CConfigMain::CreateGUIControls()
sbAdvanced->Add(AlwaysHLE_BS2, 0, wxALL, 5);
wxStaticBoxSizer* sizerCoreType = new wxStaticBoxSizer(wxVERTICAL, GeneralPage, wxT("CPU Emulator Engine"));
sizerCoreType->Add(m_RadioJIT, 0, wxALL | wxEXPAND, 5);
sizerCoreType->Add(m_RadioJITIL, 0, wxALL | wxEXPAND, 5);
sizerCoreType->Add(m_RadioInt, 0, wxALL | wxEXPAND, 5);
sbAdvanced->Add(sizerCoreType, 0, wxALL, 5);
sbAdvanced->Add(LockThreads, 0, wxALL, 5);
@ -689,11 +691,15 @@ void CConfigMain::CoreSettingsChanged(wxCommandEvent& event)
SConfig::GetInstance().m_LocalCoreStartupParameter.bHLE_BS2 = AlwaysHLE_BS2->IsChecked();
break;
case ID_RADIOJIT:
SConfig::GetInstance().m_LocalCoreStartupParameter.bUseJIT = true;
SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore = 1;
if (main_frame->g_pCodeWindow) main_frame->g_pCodeWindow->GetMenuBar()->Check(IDM_INTERPRETER, false);
break;
case ID_RADIOJITIL:
SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore = 2;
if (main_frame->g_pCodeWindow) main_frame->g_pCodeWindow->GetMenuBar()->Check(IDM_INTERPRETER, false);
break;
case ID_RADIOINT:
SConfig::GetInstance().m_LocalCoreStartupParameter.bUseJIT = false;
SConfig::GetInstance().m_LocalCoreStartupParameter.iCPUCore = 0;
if (main_frame->g_pCodeWindow) main_frame->g_pCodeWindow->GetMenuBar()->Check(IDM_INTERPRETER, true);
break;
case ID_CPUTHREAD:
@ -974,15 +980,12 @@ void CConfigMain::OnConfig(wxCommandEvent& event)
case ID_GRAPHIC_CONFIG:
CallConfig(GraphicSelection);
break;
case ID_DSP_CONFIG:
CallConfig(DSPSelection);
break;
case ID_PAD_CONFIG:
CallConfig(PADSelection);
break;
case ID_WIIMOTE_CONFIG:
CallConfig(WiimoteSelection);
break;
@ -993,11 +996,9 @@ void CConfigMain::CallConfig(wxChoice* _pChoice)
{
int Index = _pChoice->GetSelection();
INFO_LOG(CONSOLE, "CallConfig: %i\n", Index);
if (Index >= 0)
{
const CPluginInfo* pInfo = static_cast<CPluginInfo*>(_pChoice->GetClientData(Index));
if (pInfo != NULL)
CPluginManager::GetInstance().OpenConfig((HWND) this->GetHandle(), pInfo->GetFilename().c_str(), pInfo->GetPluginInfo().Type);
}
@ -1034,7 +1035,6 @@ bool CConfigMain::GetFilename(wxChoice* _pChoice, std::string& _rFilename)
{
_rFilename.clear();
int Index = _pChoice->GetSelection();
if (Index >= 0)
{
const CPluginInfo* pInfo = static_cast<CPluginInfo*>(_pChoice->GetClientData(Index));

View File

@ -63,8 +63,9 @@ private:
wxBoxSizer* sCore;
wxStaticBoxSizer* sbBasic, *sbAdvanced, *sbInterface;
wxCheckBox* AlwaysHLE_BS2;
wxRadioButton* m_RadioJIT;
wxRadioButton* m_RadioInt;
wxRadioButton* m_RadioJIT;
wxRadioButton* m_RadioJITIL;
wxCheckBox* CPUThread;
wxCheckBox* DSPThread;
wxCheckBox* LockThreads;
@ -160,6 +161,7 @@ private:
ID_ALWAYS_HLE_BS2,
ID_RADIOJIT,
ID_RADIOJITIL,
ID_RADIOINT,
ID_CPUTHREAD,
ID_DSPTHREAD,

View File

@ -39,6 +39,7 @@
#include "AboutDolphin.h"
#include "GameListCtrl.h"
#include "BootManager.h"
#include "ConsoleListener.h"
#include "ConfigManager.h" // Core
#include "Core.h"

View File

@ -40,6 +40,7 @@
#include "WxUtils.h"
#include "ConfigManager.h" // Core
#include "ConsoleListener.h"
#include "Core.h"
#include "OnFrame.h"
#include "HW/DVDInterface.h"

View File

@ -25,8 +25,10 @@
#include "Core.h" // for Core::GetState()
#include "LogWindow.h"
#include "ConsoleListener.h"
#include "Console.h"
// Milliseconds between msgQueue flushes to wxTextCtrl
#define UPDATETIME 200

View File

@ -283,7 +283,6 @@ inline void decodebytesC8_To_Raw16(u16* dst, const u8* src, int tlutaddr)
}
//inline void decodebytesC14X2(u32 *dst, const u16 *src, int numpixels, int tlutaddr, int tlutfmt)
inline void decodebytesC14X2_5A3_To_BGRA32(u32 *dst, const u16 *src, int tlutaddr)
{
u16 *tlut = (u16*)(texMem + tlutaddr);
@ -304,7 +303,7 @@ inline void decodebytesC14X2_To_Raw16(u16* dst, const u16* src, int tlutaddr)
}
}
//inline void decodebytesIA4(u16 *dst, const u8 *src, int numbytes)
// Needs more speed.
inline void decodebytesIA4(u16 *dst, const u8 *src)
{
for (int x = 0; x < 8; x++)
@ -316,7 +315,6 @@ inline void decodebytesIA4(u16 *dst, const u8 *src)
}
}
//inline void decodebytesRGB5A3(u32 *dst, const u16 *src, int numpixels)
inline void decodebytesRGB5A3(u32 *dst, const u16 *src)
{
for (int x = 0; x < 4; x++)
@ -324,6 +322,7 @@ inline void decodebytesRGB5A3(u32 *dst, const u16 *src)
}
// This one is used by many video formats. It'd therefore be good if it was fast.
// Needs more speed.
inline void decodebytesARGB8_4(u32 *dst, const u16 *src, const u16 *src2)
{
for (int x = 0; x < 4; x++) {
@ -352,6 +351,7 @@ inline u32 makeRGBA(int r, int g, int b, int a)
void decodeDXTBlock(u32 *dst, const DXTBlock *src, int pitch)
{
// S3TC Decoder (Note: GCN decodes differently from PC so we can't use native support)
// Needs more speed.
u16 c1 = Common::swap16(src->color1);
u16 c2 = Common::swap16(src->color2);
int blue1 = Convert5To8(c1 & 0x1F);
@ -523,7 +523,7 @@ PC_TexFormat TexDecoder_DirectDecode_real(u8 *dst, const u8 *src, int width, int
}
}
return PC_TEX_FMT_IA8;
case GX_TF_I8: // speed critical
case GX_TF_I8: // speed critical. Needs speed.
{
for (int y = 0; y < height; y += 4)
for (int x = 0; x < width; x += 8)
@ -531,7 +531,7 @@ PC_TexFormat TexDecoder_DirectDecode_real(u8 *dst, const u8 *src, int width, int
for (int ix = 0; ix < 8; ix++,src++)
{
int stride = (y + iy)*Pitch+(x + ix) * 2;
if(stride < TexLen)
if (stride < TexLen)
{
dst[stride] = src[0];
dst[stride + 1] = src[0];
@ -714,13 +714,14 @@ PC_TexFormat TexDecoder_DirectDecode_real(u8 *dst, const u8 *src, int width, int
case GX_TF_RGBA8: // speed critical
{
for (int y = 0; y < height; y += 4)
{
for (int x = 0; x < width; x += 4)
{
for (int iy = 0; iy < 4 && (y + iy) < height; iy++)
{
//decodebytesARGB8_4(((u32*)((u8*)dst + (y+iy)*Pitch)) + x, (u16*)src + 4 * iy, (u16*)src + 4 * iy + 16);
u16 *src1 = (u16*)src + 4 * iy;
u16 *src2 = (u16*)src + 4 * iy + 16;
u16 *src1 = (u16*)src + 4 * iy;
u16 *src2 = (u16*)src + 4 * iy + 16;
for (int ix = 0; ix < 4; ix++)
{
int stride = (y+iy)*Pitch + (x + ix) * 4;
@ -734,8 +735,10 @@ PC_TexFormat TexDecoder_DirectDecode_real(u8 *dst, const u8 *src, int width, int
}
src += 64;
}
}
}
return PC_TEX_FMT_BGRA32;
case GX_TF_CMPR: // speed critical
// The metroid games use this format almost exclusively.
{
@ -760,17 +763,17 @@ PC_TexFormat TexDecoder_DirectDecode_real(u8 *dst, const u8 *src, int width, int
#else
for (int y = 0; y < height; y += 8)
{
for (int x = 0; x < width; x += 8)
{
decodeDXTBlock(((u32*)((u8*)dst + y * Pitch)) + x, (DXTBlock*)src, width);
src += sizeof(DXTBlock);
decodeDXTBlock(((u32*)((u8*)dst + y * Pitch)) + x + 4, (DXTBlock*)src, width);
src += sizeof(DXTBlock);
decodeDXTBlock(((u32*)((u8*)dst + (y + 4) * Pitch)) + x, (DXTBlock*)src, width);
src += sizeof(DXTBlock);
decodeDXTBlock(((u32*)((u8*)dst + (y + 4) * Pitch)) + x + 4, (DXTBlock*)src, width);
src += sizeof(DXTBlock);
}
for (int x = 0; x < width; x += 8)
{
decodeDXTBlock(((u32*)((u8*)dst + y * Pitch)) + x, (DXTBlock *)src, width);
src += sizeof(DXTBlock);
decodeDXTBlock(((u32*)((u8*)dst + y * Pitch)) + x + 4, (DXTBlock *)src, width);
src += sizeof(DXTBlock);
decodeDXTBlock(((u32*)((u8*)dst + (y + 4) * Pitch)) + x, (DXTBlock *)src, width);
src += sizeof(DXTBlock);
decodeDXTBlock(((u32*)((u8*)dst + (y + 4) * Pitch)) + x + 4, (DXTBlock *)src, width);
src += sizeof(DXTBlock);
}
}
#endif
return PC_TEX_FMT_BGRA32;

View File

@ -206,8 +206,6 @@ Global
Debug|x64 = Debug|x64
DebugFast|Win32 = DebugFast|Win32
DebugFast|x64 = DebugFast|x64
Release_JITIL|Win32 = Release_JITIL|Win32
Release_JITIL|x64 = Release_JITIL|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
@ -220,10 +218,6 @@ Global
{F0B874CB-4476-4199-9315-8343D05AE684}.DebugFast|Win32.Build.0 = DebugFast|Win32
{F0B874CB-4476-4199-9315-8343D05AE684}.DebugFast|x64.ActiveCfg = DebugFast|x64
{F0B874CB-4476-4199-9315-8343D05AE684}.DebugFast|x64.Build.0 = DebugFast|x64
{F0B874CB-4476-4199-9315-8343D05AE684}.Release_JITIL|Win32.ActiveCfg = Release_JITIL|Win32
{F0B874CB-4476-4199-9315-8343D05AE684}.Release_JITIL|Win32.Build.0 = Release_JITIL|Win32
{F0B874CB-4476-4199-9315-8343D05AE684}.Release_JITIL|x64.ActiveCfg = Release_JITIL|x64
{F0B874CB-4476-4199-9315-8343D05AE684}.Release_JITIL|x64.Build.0 = Release_JITIL|x64
{F0B874CB-4476-4199-9315-8343D05AE684}.Release|Win32.ActiveCfg = Release|Win32
{F0B874CB-4476-4199-9315-8343D05AE684}.Release|Win32.Build.0 = Release|Win32
{F0B874CB-4476-4199-9315-8343D05AE684}.Release|x64.ActiveCfg = Release|x64
@ -236,10 +230,6 @@ Global
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.DebugFast|Win32.Build.0 = DebugFast|Win32
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.DebugFast|x64.ActiveCfg = DebugFast|x64
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.DebugFast|x64.Build.0 = DebugFast|x64
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release_JITIL|Win32.Build.0 = Release|Win32
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release_JITIL|x64.ActiveCfg = Release|x64
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release_JITIL|x64.Build.0 = Release|x64
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release|Win32.ActiveCfg = Release|Win32
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release|Win32.Build.0 = Release|Win32
{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}.Release|x64.ActiveCfg = Release|x64
@ -252,10 +242,6 @@ Global
{9A183B48-ECC2-4121-876A-9B3793686073}.DebugFast|Win32.Build.0 = DebugFast|Win32
{9A183B48-ECC2-4121-876A-9B3793686073}.DebugFast|x64.ActiveCfg = DebugFast|x64
{9A183B48-ECC2-4121-876A-9B3793686073}.DebugFast|x64.Build.0 = DebugFast|x64
{9A183B48-ECC2-4121-876A-9B3793686073}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{9A183B48-ECC2-4121-876A-9B3793686073}.Release_JITIL|Win32.Build.0 = Release|Win32
{9A183B48-ECC2-4121-876A-9B3793686073}.Release_JITIL|x64.ActiveCfg = Release|x64
{9A183B48-ECC2-4121-876A-9B3793686073}.Release_JITIL|x64.Build.0 = Release|x64
{9A183B48-ECC2-4121-876A-9B3793686073}.Release|Win32.ActiveCfg = Release|Win32
{9A183B48-ECC2-4121-876A-9B3793686073}.Release|Win32.Build.0 = Release|Win32
{9A183B48-ECC2-4121-876A-9B3793686073}.Release|x64.ActiveCfg = Release|x64
@ -268,10 +254,6 @@ Global
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.DebugFast|Win32.Build.0 = Release|Win32
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.DebugFast|x64.ActiveCfg = Release|x64
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.DebugFast|x64.Build.0 = Release|x64
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release_JITIL|Win32.Build.0 = Release|Win32
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release_JITIL|x64.ActiveCfg = Release|x64
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release_JITIL|x64.Build.0 = Release|x64
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release|Win32.ActiveCfg = Release|Win32
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release|Win32.Build.0 = Release|Win32
{29C2ABC1-ADA5-42CD-A5FC-96022D52A510}.Release|x64.ActiveCfg = Release|x64
@ -284,10 +266,6 @@ Global
{3E03C179-8251-46E4-81F4-466F114BAC63}.DebugFast|Win32.Build.0 = Release|Win32
{3E03C179-8251-46E4-81F4-466F114BAC63}.DebugFast|x64.ActiveCfg = Release|x64
{3E03C179-8251-46E4-81F4-466F114BAC63}.DebugFast|x64.Build.0 = Release|x64
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release_JITIL|Win32.Build.0 = Release|Win32
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release_JITIL|x64.ActiveCfg = Release|x64
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release_JITIL|x64.Build.0 = Release|x64
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release|Win32.ActiveCfg = Release|Win32
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release|Win32.Build.0 = Release|Win32
{3E03C179-8251-46E4-81F4-466F114BAC63}.Release|x64.ActiveCfg = Release|x64
@ -300,10 +278,6 @@ Global
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.DebugFast|Win32.Build.0 = DebugFast|Win32
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.DebugFast|x64.ActiveCfg = DebugFast|x64
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.DebugFast|x64.Build.0 = DebugFast|x64
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release_JITIL|Win32.Build.0 = Release|Win32
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release_JITIL|x64.ActiveCfg = Release|x64
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release_JITIL|x64.Build.0 = Release|x64
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release|Win32.ActiveCfg = Release|Win32
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release|Win32.Build.0 = Release|Win32
{B7F1A9FB-BEA8-416E-9460-AE35A6A5165C}.Release|x64.ActiveCfg = Release|x64
@ -316,10 +290,6 @@ Global
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.DebugFast|Win32.Build.0 = DebugFast|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.DebugFast|x64.ActiveCfg = DebugFast|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.DebugFast|x64.Build.0 = DebugFast|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release_JITIL|Win32.Build.0 = Release|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release_JITIL|x64.ActiveCfg = Release|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release_JITIL|x64.Build.0 = Release|x64
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|Win32.ActiveCfg = Release|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|Win32.Build.0 = Release|Win32
{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}.Release|x64.ActiveCfg = Release|x64
@ -332,10 +302,6 @@ Global
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.DebugFast|Win32.Build.0 = DebugFast|Win32
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.DebugFast|x64.ActiveCfg = DebugFast|x64
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.DebugFast|x64.Build.0 = DebugFast|x64
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release_JITIL|Win32.Build.0 = Release|Win32
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release_JITIL|x64.ActiveCfg = Release|x64
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release_JITIL|x64.Build.0 = Release|x64
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release|Win32.ActiveCfg = Release|Win32
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release|Win32.Build.0 = Release|Win32
{C573CAF7-EE6A-458E-8049-16C0BF34C2E9}.Release|x64.ActiveCfg = Release|x64
@ -348,10 +314,6 @@ Global
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.DebugFast|Win32.Build.0 = DebugFast|Win32
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.DebugFast|x64.ActiveCfg = DebugFast|x64
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.DebugFast|x64.Build.0 = DebugFast|x64
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release_JITIL|Win32.ActiveCfg = Release_JITIL|Win32
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release_JITIL|Win32.Build.0 = Release_JITIL|Win32
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release_JITIL|x64.ActiveCfg = Release_JITIL|x64
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release_JITIL|x64.Build.0 = Release_JITIL|x64
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release|Win32.ActiveCfg = Release|Win32
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release|Win32.Build.0 = Release|Win32
{A72606EF-C5C1-4954-90AD-F0F93A8D97D9}.Release|x64.ActiveCfg = Release|x64
@ -364,10 +326,6 @@ Global
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.DebugFast|Win32.Build.0 = DebugFast|Win32
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.DebugFast|x64.ActiveCfg = DebugFast|x64
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.DebugFast|x64.Build.0 = DebugFast|x64
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release_JITIL|Win32.Build.0 = Release|Win32
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release_JITIL|x64.ActiveCfg = Release|x64
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release_JITIL|x64.Build.0 = Release|x64
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release|Win32.ActiveCfg = Release|Win32
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release|Win32.Build.0 = Release|Win32
{4D3CD4C5-412B-4B49-9B1B-A68A2A129C77}.Release|x64.ActiveCfg = Release|x64
@ -380,10 +338,6 @@ Global
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.DebugFast|Win32.Build.0 = DebugFast|Win32
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.DebugFast|x64.ActiveCfg = DebugFast|x64
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.DebugFast|x64.Build.0 = DebugFast|x64
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release_JITIL|Win32.Build.0 = Release|Win32
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release_JITIL|x64.ActiveCfg = Release|x64
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release_JITIL|x64.Build.0 = Release|x64
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release|Win32.ActiveCfg = Release|Win32
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release|Win32.Build.0 = Release|Win32
{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}.Release|x64.ActiveCfg = Release|x64
@ -396,10 +350,6 @@ Global
{521498BE-6089-4780-8223-E67C22F4E068}.DebugFast|Win32.Build.0 = DebugFast|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.DebugFast|x64.ActiveCfg = DebugFast|x64
{521498BE-6089-4780-8223-E67C22F4E068}.DebugFast|x64.Build.0 = DebugFast|x64
{521498BE-6089-4780-8223-E67C22F4E068}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Release_JITIL|Win32.Build.0 = Release|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Release_JITIL|x64.ActiveCfg = Release|x64
{521498BE-6089-4780-8223-E67C22F4E068}.Release_JITIL|x64.Build.0 = Release|x64
{521498BE-6089-4780-8223-E67C22F4E068}.Release|Win32.ActiveCfg = Release|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Release|Win32.Build.0 = Release|Win32
{521498BE-6089-4780-8223-E67C22F4E068}.Release|x64.ActiveCfg = Release|x64
@ -412,10 +362,6 @@ Global
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.DebugFast|Win32.Build.0 = DebugFast|Win32
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.DebugFast|x64.ActiveCfg = DebugFast|x64
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.DebugFast|x64.Build.0 = DebugFast|x64
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release_JITIL|Win32.Build.0 = Release|Win32
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release_JITIL|x64.ActiveCfg = Release|x64
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release_JITIL|x64.Build.0 = Release|x64
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release|Win32.ActiveCfg = Release|Win32
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release|Win32.Build.0 = Release|Win32
{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}.Release|x64.ActiveCfg = Release|x64
@ -428,10 +374,6 @@ Global
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.DebugFast|Win32.Build.0 = Release|Win32
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.DebugFast|x64.ActiveCfg = Release|x64
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.DebugFast|x64.Build.0 = Release|x64
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release_JITIL|Win32.Build.0 = Release|Win32
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release_JITIL|x64.ActiveCfg = Release|x64
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release_JITIL|x64.Build.0 = Release|x64
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release|Win32.ActiveCfg = Release|Win32
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release|Win32.Build.0 = Release|Win32
{33546D62-7F34-4EA6-A88E-D538B36E16BF}.Release|x64.ActiveCfg = Release|x64
@ -444,10 +386,6 @@ Global
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.DebugFast|Win32.Build.0 = DebugFast|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.DebugFast|x64.ActiveCfg = DebugFast|x64
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.DebugFast|x64.Build.0 = DebugFast|x64
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release_JITIL|Win32.Build.0 = Release|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release_JITIL|x64.ActiveCfg = Release|x64
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release_JITIL|x64.Build.0 = Release|x64
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release|Win32.ActiveCfg = Release|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release|Win32.Build.0 = Release|Win32
{8D612734-FAA5-4B8A-804F-4DEA2367D495}.Release|x64.ActiveCfg = Release|x64
@ -460,10 +398,6 @@ Global
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.DebugFast|Win32.Build.0 = DebugFast|Win32
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.DebugFast|x64.ActiveCfg = DebugFast|x64
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.DebugFast|x64.Build.0 = DebugFast|x64
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release_JITIL|Win32.Build.0 = Release|Win32
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release_JITIL|x64.ActiveCfg = Release|x64
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release_JITIL|x64.Build.0 = Release|x64
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release|Win32.ActiveCfg = Release|Win32
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release|Win32.Build.0 = Release|Win32
{C7E5D50A-2916-464B-86A7-E10B3CC88ADA}.Release|x64.ActiveCfg = Release|x64
@ -476,10 +410,6 @@ Global
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.DebugFast|Win32.Build.0 = DebugFast|Win32
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.DebugFast|x64.ActiveCfg = DebugFast|x64
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.DebugFast|x64.Build.0 = DebugFast|x64
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release_JITIL|Win32.Build.0 = Release|Win32
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release_JITIL|x64.ActiveCfg = Release|x64
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release_JITIL|x64.Build.0 = Release|x64
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release|Win32.ActiveCfg = Release|Win32
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release|Win32.Build.0 = Release|Win32
{FBAFB369-07EB-4460-9CAD-08BE5789DAB6}.Release|x64.ActiveCfg = Release|x64
@ -492,10 +422,6 @@ Global
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.DebugFast|Win32.Build.0 = DebugFast|Win32
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.DebugFast|x64.ActiveCfg = DebugFast|x64
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.DebugFast|x64.Build.0 = DebugFast|x64
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release_JITIL|Win32.Build.0 = Release|Win32
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release_JITIL|x64.ActiveCfg = Release|x64
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release_JITIL|x64.Build.0 = Release|x64
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release|Win32.ActiveCfg = Release|Win32
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release|Win32.Build.0 = Release|Win32
{3D8156A9-64D1-4C8E-ADBE-1B319030E4A4}.Release|x64.ActiveCfg = Release|x64
@ -508,10 +434,6 @@ Global
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.DebugFast|Win32.Build.0 = DebugFast|Win32
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.DebugFast|x64.ActiveCfg = DebugFast|x64
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.DebugFast|x64.Build.0 = DebugFast|x64
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release_JITIL|Win32.Build.0 = Release|Win32
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release_JITIL|x64.ActiveCfg = Release|x64
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release_JITIL|x64.Build.0 = Release|x64
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release|Win32.ActiveCfg = Release|Win32
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release|Win32.Build.0 = Release|Win32
{838A89A3-3AA0-4A45-ACBE-3D1E0980C2ED}.Release|x64.ActiveCfg = Release|x64
@ -524,10 +446,6 @@ Global
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.DebugFast|Win32.Build.0 = DebugFast|Win32
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.DebugFast|x64.ActiveCfg = DebugFast|x64
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.DebugFast|x64.Build.0 = DebugFast|x64
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release_JITIL|Win32.Build.0 = Release|Win32
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release_JITIL|x64.ActiveCfg = Release|x64
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release_JITIL|x64.Build.0 = Release|x64
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release|Win32.ActiveCfg = Release|Win32
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release|x64.ActiveCfg = Release|x64
{1970D175-3DE8-4738-942A-4D98D1CDBF64}.Release|x64.Build.0 = Release|x64
@ -535,8 +453,6 @@ Global
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.Debug|x64.ActiveCfg = Wii|x64
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.DebugFast|Win32.ActiveCfg = Wii|Win32
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.DebugFast|x64.ActiveCfg = Wii|x64
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.Release_JITIL|Win32.ActiveCfg = Wii|Win32
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.Release_JITIL|x64.ActiveCfg = Wii|x64
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.Release|Win32.ActiveCfg = Wii|Win32
{3877AA3E-9CC0-4ADF-8E71-272EE4443478}.Release|x64.ActiveCfg = Wii|x64
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Debug|Win32.ActiveCfg = Debug|Win32
@ -547,10 +463,6 @@ Global
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.DebugFast|Win32.Build.0 = Release|Win32
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.DebugFast|x64.ActiveCfg = Release|x64
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.DebugFast|x64.Build.0 = Release|x64
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release_JITIL|Win32.Build.0 = Release|Win32
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release_JITIL|x64.ActiveCfg = Release|x64
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release_JITIL|x64.Build.0 = Release|x64
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release|Win32.ActiveCfg = Release|Win32
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release|Win32.Build.0 = Release|Win32
{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}.Release|x64.ActiveCfg = Release|x64
@ -563,10 +475,6 @@ Global
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.DebugFast|Win32.Build.0 = Release|Win32
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.DebugFast|x64.ActiveCfg = Release|x64
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.DebugFast|x64.Build.0 = Release|x64
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release_JITIL|Win32.Build.0 = Release|Win32
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release_JITIL|x64.ActiveCfg = Release|x64
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release_JITIL|x64.Build.0 = Release|x64
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release|Win32.ActiveCfg = Release|Win32
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release|Win32.Build.0 = Release|Win32
{823DDC98-42D5-4A38-88CF-9DC06C788AE4}.Release|x64.ActiveCfg = Release|x64
@ -577,10 +485,6 @@ Global
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.DebugFast|Win32.Build.0 = Release|Win32
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.DebugFast|x64.ActiveCfg = Release|x64
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.DebugFast|x64.Build.0 = Release|x64
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release_JITIL|Win32.Build.0 = Release|Win32
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release_JITIL|x64.ActiveCfg = Release|x64
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release_JITIL|x64.Build.0 = Release|x64
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release|Win32.ActiveCfg = Release|Win32
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release|Win32.Build.0 = Release|Win32
{40C636FA-B5BF-4D67-ABC8-376B524A7551}.Release|x64.ActiveCfg = Release|x64
@ -593,10 +497,6 @@ Global
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.DebugFast|Win32.Build.0 = DebugFast|Win32
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.DebugFast|x64.ActiveCfg = DebugFast|x64
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.DebugFast|x64.Build.0 = DebugFast|x64
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release_JITIL|Win32.Build.0 = Release|Win32
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release_JITIL|x64.ActiveCfg = Release|x64
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release_JITIL|x64.Build.0 = Release|x64
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release|Win32.ActiveCfg = Release|Win32
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release|Win32.Build.0 = Release|Win32
{F81AE75C-3D17-4D8C-A201-82FA5351C123}.Release|x64.ActiveCfg = Release|x64
@ -609,10 +509,6 @@ Global
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.DebugFast|Win32.Build.0 = Release|Win32
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.DebugFast|x64.ActiveCfg = Release|x64
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.DebugFast|x64.Build.0 = Release|x64
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release_JITIL|Win32.Build.0 = Release|Win32
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release_JITIL|x64.ActiveCfg = Release|x64
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release_JITIL|x64.Build.0 = Release|x64
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release|Win32.ActiveCfg = Release|Win32
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release|Win32.Build.0 = Release|Win32
{DA4CA030-A741-4DDC-9DA8-B2F351F0F158}.Release|x64.ActiveCfg = Release|x64
@ -625,10 +521,6 @@ Global
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.DebugFast|Win32.Build.0 = Release|Win32
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.DebugFast|x64.ActiveCfg = Release|x64
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.DebugFast|x64.Build.0 = Release|x64
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release_JITIL|Win32.Build.0 = Release|Win32
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release_JITIL|x64.ActiveCfg = Release|x64
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release_JITIL|x64.Build.0 = Release|x64
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release|Win32.ActiveCfg = Release|Win32
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release|Win32.Build.0 = Release|Win32
{0E231FB1-F3C9-4724-ACCB-DE8BCB3C089E}.Release|x64.ActiveCfg = Release|x64
@ -641,10 +533,6 @@ Global
{05C75041-D67D-4903-A362-8395A7B35C75}.DebugFast|Win32.Build.0 = Release|Win32
{05C75041-D67D-4903-A362-8395A7B35C75}.DebugFast|x64.ActiveCfg = Release|x64
{05C75041-D67D-4903-A362-8395A7B35C75}.DebugFast|x64.Build.0 = Release|x64
{05C75041-D67D-4903-A362-8395A7B35C75}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{05C75041-D67D-4903-A362-8395A7B35C75}.Release_JITIL|Win32.Build.0 = Release|Win32
{05C75041-D67D-4903-A362-8395A7B35C75}.Release_JITIL|x64.ActiveCfg = Release|x64
{05C75041-D67D-4903-A362-8395A7B35C75}.Release_JITIL|x64.Build.0 = Release|x64
{05C75041-D67D-4903-A362-8395A7B35C75}.Release|Win32.ActiveCfg = Release|Win32
{05C75041-D67D-4903-A362-8395A7B35C75}.Release|Win32.Build.0 = Release|Win32
{05C75041-D67D-4903-A362-8395A7B35C75}.Release|x64.ActiveCfg = Release|x64
@ -657,10 +545,6 @@ Global
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.DebugFast|Win32.Build.0 = Release|Win32
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.DebugFast|x64.ActiveCfg = Release|x64
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.DebugFast|x64.Build.0 = Release|x64
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release_JITIL|Win32.Build.0 = Release|Win32
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release_JITIL|x64.ActiveCfg = Release|x64
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release_JITIL|x64.Build.0 = Release|x64
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release|Win32.ActiveCfg = Release|Win32
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release|Win32.Build.0 = Release|Win32
{1C8436C9-DBAF-42BE-83BC-CF3EC9175ABE}.Release|x64.ActiveCfg = Release|x64
@ -673,10 +557,6 @@ Global
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.DebugFast|Win32.Build.0 = Release|Win32
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.DebugFast|x64.ActiveCfg = Release|x64
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.DebugFast|x64.Build.0 = Release|x64
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release_JITIL|Win32.Build.0 = Release|Win32
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release_JITIL|x64.ActiveCfg = Release|x64
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release_JITIL|x64.Build.0 = Release|x64
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release|Win32.ActiveCfg = Release|Win32
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release|Win32.Build.0 = Release|Win32
{11F55366-12EC-4C44-A8CB-1D4E315D61ED}.Release|x64.ActiveCfg = Release|x64
@ -689,30 +569,10 @@ Global
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.DebugFast|Win32.Build.0 = Release|Win32
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.DebugFast|x64.ActiveCfg = Release|x64
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.DebugFast|x64.Build.0 = Release|x64
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release_JITIL|Win32.Build.0 = Release|Win32
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release_JITIL|x64.ActiveCfg = Release|x64
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release_JITIL|x64.Build.0 = Release|x64
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release|Win32.ActiveCfg = Release|Win32
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release|Win32.Build.0 = Release|Win32
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release|x64.ActiveCfg = Release|x64
{66A4E7BD-E2E8-4373-9B75-8750EB5AE683}.Release|x64.Build.0 = Release|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.Debug|Win32.ActiveCfg = Debug|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.Debug|Win32.Build.0 = Debug|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.Debug|x64.ActiveCfg = Debug|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.Debug|x64.Build.0 = Debug|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.DebugFast|Win32.ActiveCfg = Release|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.DebugFast|Win32.Build.0 = Release|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.DebugFast|x64.ActiveCfg = Release|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.DebugFast|x64.Build.0 = Release|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release_JITIL|Win32.ActiveCfg = Release|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release_JITIL|Win32.Build.0 = Release|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release_JITIL|x64.ActiveCfg = Release|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release_JITIL|x64.Build.0 = Release|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release|Win32.ActiveCfg = Release|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release|Win32.Build.0 = Release|Win32
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release|x64.ActiveCfg = Release|x64
{E251479F-74CD-462C-90E4-0F8345AA6628}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

View File

@ -2,23 +2,18 @@
//________________________________________________________________________________________
// File description: Common plugin spec, version #1.0 maintained by F|RES
#ifndef _PLUGINS_H_INCLUDED__
#define _PLUGINS_H_INCLUDED__
// Includes
// ------------
// TODO: See if we can get rid of the windows.h include.
#ifdef _WIN32
#include <windows.h>
#endif
#include "CommonTypes.h"
/* Plugin communication. I place this here rather in Common.h to rebuild less if any of this is changed */
// Plugin communication. I place this here rather in Common.h to rebuild less if any of this is changed
// -----------------
enum PLUGIN_COMM
{
@ -34,9 +29,6 @@ enum PLUGIN_COMM
INPUT_FRAME_COUNTER // Wind back the frame counter for rerecording
};
// System specific declarations and definitions
// ------------
@ -64,7 +56,6 @@ enum PLUGIN_COMM
// Global values
// ------------