From 1e2cc8eb90150b3daadb02a8ce18bb6f45f26008 Mon Sep 17 00:00:00 2001 From: zilmar Date: Tue, 28 Jun 2016 06:12:04 +1000 Subject: [PATCH] [Project64] Get x86ops to use a function not a macro --- .../N64System/Recompiler/x86/x86ops.cpp | 2097 +++++++++-------- .../N64System/Recompiler/x86/x86ops.h | 3 + 2 files changed, 1062 insertions(+), 1038 deletions(-) diff --git a/Source/Project64-core/N64System/Recompiler/x86/x86ops.cpp b/Source/Project64-core/N64System/Recompiler/x86/x86ops.cpp index f35d37e11..435424cca 100644 --- a/Source/Project64-core/N64System/Recompiler/x86/x86ops.cpp +++ b/Source/Project64-core/N64System/Recompiler/x86/x86ops.cpp @@ -14,10 +14,6 @@ #include #include -#define PUTDST8(dest,value) (*((uint8_t *)(dest))=(uint8_t)(value)); dest += 1; -#define PUTDST16(dest,value) (*((uint16_t *)(dest))=(uint16_t)(value)); dest += 2; -#define PUTDST32(dest,value) (*((uint32_t *)(dest))=(uint32_t)(value)); dest += 4; - uint8_t * CX86Ops::m_RecompPos; char CX86Ops::m_fpupop[2][2] = @@ -55,16 +51,16 @@ void CX86Ops::WriteX86Label(const char * Label) void CX86Ops::AdcX86regToVariable(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" adc dword ptr [%s], %s", VariableName, x86_Name(reg)); - PUTDST16(m_RecompPos, 0x0511 + (reg * 0x100)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0511 + (reg * 0x100))); + AddCode32((uint32_t)Variable); } void CX86Ops::AdcConstToVariable(void *Variable, const char * VariableName, uint8_t Constant) { CPU_Message(" adc dword ptr [%s], %Xh", VariableName, Constant); - PUTDST16(m_RecompPos, 0x1583); - PUTDST32(m_RecompPos, Variable); - PUTDST8(m_RecompPos, Constant); + AddCode16(0x1583); + AddCode32((uint32_t)Variable); + AddCode8(Constant); } void CX86Ops::AdcConstToX86Reg(x86Reg reg, uint32_t Const) @@ -72,35 +68,35 @@ void CX86Ops::AdcConstToX86Reg(x86Reg reg, uint32_t Const) CPU_Message(" adc %s, %Xh", x86_Name(reg), Const); if ((Const & 0xFFFFFF80) != 0 && (Const & 0xFFFFFF80) != 0xFFFFFF80) { - PUTDST16(m_RecompPos, 0xD081 + (reg * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0xD081 + (reg * 0x100))); + AddCode32(Const); } else { - PUTDST16(m_RecompPos, 0xD083 + (reg * 0x100)); - PUTDST8(m_RecompPos, Const); + AddCode16((uint16_t)(0xD083 + (reg * 0x100))); + AddCode8((uint8_t)Const); } } void CX86Ops::AdcVariableToX86reg(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" adc %s, dword ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0x0513 + (reg * 0x800)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0513 + (reg * 0x800))); + AddCode32((uint32_t)Variable); } void CX86Ops::AdcX86RegToX86Reg(x86Reg Destination, x86Reg Source) { CPU_Message(" adc %s, %s", x86_Name(Destination), x86_Name(Source)); - PUTDST16(m_RecompPos, 0xC013 + (Source * 0x100) + (Destination * 0x800)); + AddCode16((uint16_t)(0xC013 + (Source * 0x100) + (Destination * 0x800))); } void CX86Ops::AddConstToVariable(uint32_t Const, void *Variable, const char * VariableName) { CPU_Message(" add dword ptr [%s], 0x%X", VariableName, Const); - PUTDST16(m_RecompPos, 0x0581); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x0581); + AddCode32((uint32_t)Variable); + AddCode32(Const); } void CX86Ops::AddConstToX86Reg(x86Reg reg, uint32_t Const) @@ -119,43 +115,43 @@ void CX86Ops::AddConstToX86Reg(x86Reg reg, uint32_t Const) else if ((Const & 0xFFFFFF80) != 0 && (Const & 0xFFFFFF80) != 0xFFFFFF80) { CPU_Message(" add %s, %Xh", x86_Name(reg), Const); - PUTDST16(m_RecompPos, 0xC081 + (reg * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0xC081 + (reg * 0x100))); + AddCode32(Const); } else { CPU_Message(" add %s, %Xh", x86_Name(reg), Const); - PUTDST16(m_RecompPos, 0xC083 + (reg * 0x100)); - PUTDST8(m_RecompPos, Const); + AddCode16((uint16_t)(0xC083 + (reg * 0x100))); + AddCode8((uint8_t)Const); } } void CX86Ops::AddVariableToX86reg(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" add %s, dword ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0x0503 + (reg * 0x800)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0503 + (reg * 0x800))); + AddCode32((uint32_t)Variable); } void CX86Ops::AddX86regToVariable(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" add dword ptr [%s], %s", VariableName, x86_Name(reg)); - PUTDST16(m_RecompPos, 0x0501 + (reg * 0x800)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0501 + (reg * 0x800))); + AddCode32((uint32_t)Variable); } void CX86Ops::AddX86RegToX86Reg(x86Reg Destination, x86Reg Source) { CPU_Message(" add %s, %s", x86_Name(Destination), x86_Name(Source)); - PUTDST16(m_RecompPos, 0xC003 + (Source * 0x100) + (Destination * 0x800)); + AddCode16((uint16_t)(0xC003 + (Source * 0x100) + (Destination * 0x800))); } void CX86Ops::AndConstToVariable(uint32_t Const, void *Variable, const char * VariableName) { CPU_Message(" and dword ptr [%s], 0x%X", VariableName, Const); - PUTDST16(m_RecompPos, 0x2581); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x2581); + AddCode32((uint32_t)Variable); + AddCode32(Const); } void CX86Ops::AndConstToX86Reg(x86Reg reg, uint32_t Const) @@ -163,13 +159,13 @@ void CX86Ops::AndConstToX86Reg(x86Reg reg, uint32_t Const) CPU_Message(" and %s, %Xh", x86_Name(reg), Const); if ((Const & 0xFFFFFF80) != 0 && (Const & 0xFFFFFF80) != 0xFFFFFF80) { - PUTDST16(m_RecompPos, 0xE081 + (reg * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0xE081 + (reg * 0x100))); + AddCode32(Const); } else { - PUTDST16(m_RecompPos, 0xE083 + (reg * 0x100)); - PUTDST8(m_RecompPos, Const); + AddCode16((uint16_t)(0xE083 + (reg * 0x100))); + AddCode8((uint8_t)Const); } } @@ -177,22 +173,22 @@ void CX86Ops::AndVariableDispToX86Reg(void *Variable, const char * VariableName, { CPU_Message(" and %s, dword ptr [%s+%s*%i]", x86_Name(reg), VariableName, x86_Name(AddrReg), Multiply); - PUTDST16(m_RecompPos, 0x0423 + (reg * 0x800)); - PUTDST8(m_RecompPos, 0x05 + CalcMultiplyCode(Multiply) + (AddrReg * 0x8)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0423 + (reg * 0x800))); + AddCode8((uint8_t)(0x05 + CalcMultiplyCode(Multiply) + (AddrReg * 0x8))); + AddCode32((uint32_t)(Variable)); } void CX86Ops::AndVariableToX86Reg(void * Variable, const char * VariableName, x86Reg reg) { CPU_Message(" and %s, dword ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0x0523 + (reg * 0x800)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0523 + (reg * 0x800))); + AddCode32((uint32_t)(Variable)); } void CX86Ops::AndX86RegToX86Reg(x86Reg Destination, x86Reg Source) { CPU_Message(" and %s, %s", x86_Name(Destination), x86_Name(Source)); - PUTDST16(m_RecompPos, 0xC021 + (Destination * 0x100) + (Source * 0x800)); + AddCode16((uint16_t)(0xC021 + (Destination * 0x100) + (Source * 0x800))); } void CX86Ops::BreakPointNotification(const char * FileName, int32_t LineNumber) @@ -203,7 +199,7 @@ void CX86Ops::BreakPointNotification(const char * FileName, int32_t LineNumber) void CX86Ops::X86HardBreakPoint() { CPU_Message(" int 3"); - PUTDST8(m_RecompPos, 0xCC); + AddCode8(0xCC); } void CX86Ops::X86BreakPoint(const char * FileName, int LineNumber) @@ -219,23 +215,23 @@ void CX86Ops::X86BreakPoint(const char * FileName, int LineNumber) void CX86Ops::Call_Direct(void * FunctAddress, const char * FunctName) { CPU_Message(" call offset %s", FunctName); - PUTDST8(m_RecompPos, 0xE8); - PUTDST32(m_RecompPos, (uint32_t)FunctAddress - (uint32_t)m_RecompPos - 4); + AddCode8(0xE8); + AddCode32((uint32_t)FunctAddress - (uint32_t)*g_RecompPos - 4); } void CX86Ops::Call_Indirect(void * FunctAddress, const char * FunctName) { CPU_Message(" call [%s]", FunctName); - PUTDST16(m_RecompPos, 0x15FF); - PUTDST32(m_RecompPos, FunctAddress); + AddCode16(0x15FF); + AddCode32((uint32_t)FunctAddress); } void CX86Ops::CompConstToVariable(uint32_t Const, void * Variable, const char * VariableName) { CPU_Message(" cmp dword ptr [%s], 0x%X", VariableName, Const); - PUTDST16(m_RecompPos, 0x3D81); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x3D81); + AddCode32((uint32_t)Variable); + AddCode32(Const); } void CX86Ops::CompConstToX86reg(x86Reg reg, uint32_t Const) @@ -249,13 +245,13 @@ void CX86Ops::CompConstToX86reg(x86Reg reg, uint32_t Const) CPU_Message(" cmp %s, %Xh", x86_Name(reg), Const); if ((Const & 0xFFFFFF80) != 0 && (Const & 0xFFFFFF80) != 0xFFFFFF80) { - PUTDST16(m_RecompPos, 0xF881 + (reg * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0xF881 + (reg * 0x100))); + AddCode32(Const); } else { - PUTDST16(m_RecompPos, 0xF883 + (reg * 0x100)); - PUTDST8(m_RecompPos, Const); + AddCode16((uint16_t)(0xF883 + (reg * 0x100))); + AddCode8((uint8_t)Const); } } } @@ -265,29 +261,29 @@ void CX86Ops::CompConstToX86regPointer(x86Reg reg, uint32_t Const) if ((Const & 0xFFFFFF80) != 0 && (Const & 0xFFFFFF80) != 0xFFFFFF80) { CPU_Message(" cmp dword ptr [%s], %Xh", x86_Name(reg), Const); - PUTDST16(m_RecompPos, 0x3881 + (reg * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0x3881 + (reg * 0x100))); + AddCode32(Const); } else { CPU_Message(" cmp byte ptr [%s], %Xh", x86_Name(reg), Const); - PUTDST16(m_RecompPos, 0x3883 + (reg * 0x100)); - PUTDST8(m_RecompPos, Const); + AddCode16((uint16_t)(0x3883 + (reg * 0x100))); + AddCode8((uint8_t)Const); } } void CX86Ops::CompX86regToVariable(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" cmp %s, dword ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0x053B + (reg * 0x800)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x053B + (reg * 0x800))); + AddCode32((uint32_t)Variable); } void CX86Ops::CompVariableToX86reg(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" cmp dword ptr [%s], %s", VariableName, x86_Name(reg)); - PUTDST16(m_RecompPos, 0x0539 + (reg * 0x800)); - PUTDST32(m_RecompPos, Variable); + AddCode16((uint16_t)(0x0539 + (reg * 0x800))); + AddCode32((uint32_t)Variable); } void CX86Ops::CompX86RegToX86Reg(x86Reg Destination, x86Reg Source) @@ -320,7 +316,7 @@ void CX86Ops::CompX86RegToX86Reg(x86Reg Destination, x86Reg Source) case x86_ESP: x86Command += 0xE000; break; case x86_EBP: x86Command += 0xE800; break; } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::DecX86reg(x86Reg reg) @@ -329,14 +325,14 @@ void CX86Ops::DecX86reg(x86Reg reg) switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xC8FF); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xCBFF); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xC9FF); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xCAFF); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xCEFF); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xCFFF); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x4C); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x4D); break; + case x86_EAX: AddCode16(0xC8FF); break; + case x86_EBX: AddCode16(0xCBFF); break; + case x86_ECX: AddCode16(0xC9FF); break; + case x86_EDX: AddCode16(0xCAFF); break; + case x86_ESI: AddCode16(0xCEFF); break; + case x86_EDI: AddCode16(0xCFFF); break; + case x86_ESP: AddCode8(0x4C); break; + case x86_EBP: AddCode8(0x4D); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -347,13 +343,13 @@ void CX86Ops::DivX86reg(x86Reg reg) CPU_Message(" div %s", x86_Name(reg)); switch (reg) { - case x86_EBX: PUTDST16(m_RecompPos, 0xf3F7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xf1F7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xf2F7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xf6F7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xf7F7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xf4F7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xf5F7); break; + case x86_EBX: AddCode16(0xf3F7); break; + case x86_ECX: AddCode16(0xf1F7); break; + case x86_EDX: AddCode16(0xf2F7); break; + case x86_ESI: AddCode16(0xf6F7); break; + case x86_EDI: AddCode16(0xf7F7); break; + case x86_ESP: AddCode16(0xf4F7); break; + case x86_EBP: AddCode16(0xf5F7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -365,13 +361,13 @@ void CX86Ops::idivX86reg(x86Reg reg) switch (reg) { - case x86_EBX: PUTDST16(m_RecompPos, 0xfbF7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xf9F7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xfaF7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xfeF7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xffF7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xfcF7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xfdF7); break; + case x86_EBX: AddCode16(0xfbF7); break; + case x86_ECX: AddCode16(0xf9F7); break; + case x86_EDX: AddCode16(0xfaF7); break; + case x86_ESI: AddCode16(0xfeF7); break; + case x86_EDI: AddCode16(0xffF7); break; + case x86_ESP: AddCode16(0xfcF7); break; + case x86_EBP: AddCode16(0xfdF7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -383,14 +379,14 @@ void CX86Ops::imulX86reg(x86Reg reg) switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE8F7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xEBF7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE9F7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xEAF7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xEEF7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xEFF7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xECF7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xEDF7); break; + case x86_EAX: AddCode16(0xE8F7); break; + case x86_EBX: AddCode16(0xEBF7); break; + case x86_ECX: AddCode16(0xE9F7); break; + case x86_EDX: AddCode16(0xEAF7); break; + case x86_ESI: AddCode16(0xEEF7); break; + case x86_EDI: AddCode16(0xEFF7); break; + case x86_ESP: AddCode16(0xECF7); break; + case x86_EBP: AddCode16(0xEDF7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -402,14 +398,14 @@ void CX86Ops::IncX86reg(x86Reg reg) switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xC0FF); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xC3FF); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xC1FF); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xC2FF); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xC6FF); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xC7FF); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x44); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x45); break; + case x86_EAX: AddCode16(0xC0FF); break; + case x86_EBX: AddCode16(0xC3FF); break; + case x86_ECX: AddCode16(0xC1FF); break; + case x86_EDX: AddCode16(0xC2FF); break; + case x86_ESI: AddCode16(0xC6FF); break; + case x86_EDI: AddCode16(0xC7FF); break; + case x86_ESP: AddCode8(0x44); break; + case x86_EBP: AddCode8(0x45); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -418,113 +414,113 @@ void CX86Ops::IncX86reg(x86Reg reg) void CX86Ops::JaeLabel8(const char * Label, uint8_t Value) { CPU_Message(" jae $%s", Label); - PUTDST8(m_RecompPos, 0x73); - PUTDST8(m_RecompPos, Value); + AddCode8(0x73); + AddCode8(Value); } void CX86Ops::JaeLabel32(const char * Label, uint32_t Value) { CPU_Message(" jae $%s", Label); - PUTDST16(m_RecompPos, 0x830F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x830F); + AddCode32(Value); } void CX86Ops::JaLabel8(const char * Label, uint8_t Value) { CPU_Message(" ja $%s", Label); - PUTDST8(m_RecompPos, 0x77); - PUTDST8(m_RecompPos, Value); + AddCode8(0x77); + AddCode8(Value); } void CX86Ops::JaLabel32(const char * Label, uint32_t Value) { CPU_Message(" ja $%s", Label); - PUTDST16(m_RecompPos, 0x870F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x870F); + AddCode32(Value); } void CX86Ops::JbLabel8(const char * Label, uint8_t Value) { CPU_Message(" jb $%s", Label); - PUTDST8(m_RecompPos, 0x72); - PUTDST8(m_RecompPos, Value); + AddCode8(0x72); + AddCode8(Value); } void CX86Ops::JbLabel32(const char * Label, uint32_t Value) { CPU_Message(" jb $%s", Label); - PUTDST16(m_RecompPos, 0x820F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x820F); + AddCode32(Value); } void CX86Ops::JecxzLabel8(const char * Label, uint8_t Value) { CPU_Message(" jecxz $%s", Label); - PUTDST8(m_RecompPos, 0xE3); - PUTDST8(m_RecompPos, Value); + AddCode8(0xE3); + AddCode8(Value); } void CX86Ops::JeLabel8(const char * Label, uint8_t Value) { CPU_Message(" je $%s", Label); - PUTDST8(m_RecompPos, 0x74); - PUTDST8(m_RecompPos, Value); + AddCode8(0x74); + AddCode8(Value); } void CX86Ops::JeLabel32(const char * Label, uint32_t Value) { CPU_Message(" je $%s", Label); - PUTDST16(m_RecompPos, 0x840F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x840F); + AddCode32(Value); } void CX86Ops::JgeLabel32(const char * Label, uint32_t Value) { CPU_Message(" jge $%s", Label); - PUTDST16(m_RecompPos, 0x8D0F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x8D0F); + AddCode32(Value); } void CX86Ops::JgLabel8(const char * Label, uint8_t Value) { CPU_Message(" jg $%s", Label); - PUTDST8(m_RecompPos, 0x7F); - PUTDST8(m_RecompPos, Value); + AddCode8(0x7F); + AddCode8(Value); } void CX86Ops::JgLabel32(const char * Label, uint32_t Value) { CPU_Message(" jg $%s", Label); - PUTDST16(m_RecompPos, 0x8F0F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x8F0F); + AddCode32(Value); } void CX86Ops::JleLabel8(const char * Label, uint8_t Value) { CPU_Message(" jle $%s", Label); - PUTDST8(m_RecompPos, 0x7E); - PUTDST8(m_RecompPos, Value); + AddCode8(0x7E); + AddCode8(Value); } void CX86Ops::JleLabel32(const char * Label, uint32_t Value) { CPU_Message(" jle $%s", Label); - PUTDST16(m_RecompPos, 0x8E0F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x8E0F); + AddCode32(Value); } void CX86Ops::JlLabel8(const char * Label, uint8_t Value) { CPU_Message(" jl $%s", Label); - PUTDST8(m_RecompPos, 0x7C); - PUTDST8(m_RecompPos, Value); + AddCode8(0x7C); + AddCode8(Value); } void CX86Ops::JlLabel32(const char * Label, uint32_t Value) { CPU_Message(" jl $%s", Label); - PUTDST16(m_RecompPos, 0x8C0F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x8C0F); + AddCode32(Value); } void CX86Ops::JmpDirectReg(x86Reg reg) @@ -533,12 +529,12 @@ void CX86Ops::JmpDirectReg(x86Reg reg) switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE0ff); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xE3ff); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE1ff); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xE2ff); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xE6ff); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xE7ff); break; + case x86_EAX: AddCode16(0xE0ff); break; + case x86_EBX: AddCode16(0xE3ff); break; + case x86_ECX: AddCode16(0xE1ff); break; + case x86_EDX: AddCode16(0xE2ff); break; + case x86_ESI: AddCode16(0xE6ff); break; + case x86_EDI: AddCode16(0xE7ff); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -547,8 +543,8 @@ void CX86Ops::JmpDirectReg(x86Reg reg) void CX86Ops::JmpIndirectLabel32(const char * Label, uint32_t location) { CPU_Message(" jmp dword ptr [%s]", Label); - PUTDST16(m_RecompPos, 0x25ff); - PUTDST32(m_RecompPos, location); + AddCode16(0x25ff); + AddCode32(location); } void CX86Ops::JmpIndirectReg(x86Reg reg) @@ -556,20 +552,20 @@ void CX86Ops::JmpIndirectReg(x86Reg reg) CPU_Message(" jmp dword ptr [%s]", x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x20ff); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x23ff); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x21ff); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x22ff); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x26ff); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x27ff); break; + case x86_EAX: AddCode16(0x20ff); break; + case x86_EBX: AddCode16(0x23ff); break; + case x86_ECX: AddCode16(0x21ff); break; + case x86_EDX: AddCode16(0x22ff); break; + case x86_ESI: AddCode16(0x26ff); break; + case x86_EDI: AddCode16(0x27ff); break; case x86_ESP: - PUTDST8(m_RecompPos, 0xff); - PUTDST16(m_RecompPos, 0x2434); + AddCode8(0xff); + AddCode16(0x2434); /* g_Notify->BreakPoint(__FILEW__,__LINE__); */ break; case x86_EBP: - PUTDST8(m_RecompPos, 0xff); - PUTDST16(m_RecompPos, 0x0065); + AddCode8(0xff); + AddCode16(0x0065); /* g_Notify->BreakPoint(__FILEW__,__LINE__); */ break; } @@ -578,78 +574,78 @@ void CX86Ops::JmpIndirectReg(x86Reg reg) void CX86Ops::JmpLabel8(const char * Label, uint8_t Value) { CPU_Message(" jmp $%s", Label); - PUTDST8(m_RecompPos, 0xEB); - PUTDST8(m_RecompPos, Value); + AddCode8(0xEB); + AddCode8(Value); } void CX86Ops::JmpLabel32(const char * Label, uint32_t Value) { CPU_Message(" jmp $%s", Label); - PUTDST8(m_RecompPos, 0xE9); - PUTDST32(m_RecompPos, Value); + AddCode8(0xE9); + AddCode32(Value); } void CX86Ops::JneLabel8(const char * Label, uint8_t Value) { CPU_Message(" jne $%s", Label); - PUTDST8(m_RecompPos, 0x75); - PUTDST8(m_RecompPos, Value); + AddCode8(0x75); + AddCode8(Value); } void CX86Ops::JneLabel32(const char *Label, uint32_t Value) { CPU_Message(" jne $%s", Label); - PUTDST16(m_RecompPos, 0x850F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x850F); + AddCode32(Value); } void CX86Ops::JnsLabel8(const char * Label, uint8_t Value) { CPU_Message(" jns $%s", Label); - PUTDST8(m_RecompPos, 0x79); - PUTDST8(m_RecompPos, Value); + AddCode8(0x79); + AddCode8(Value); } void CX86Ops::JnsLabel32(const char *Label, uint32_t Value) { CPU_Message(" jns $%s", Label); - PUTDST16(m_RecompPos, 0x890F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x890F); + AddCode32(Value); } void CX86Ops::JnzLabel8(const char *Label, uint8_t Value) { CPU_Message(" jnz $%s", Label); - PUTDST8(m_RecompPos, 0x75); - PUTDST8(m_RecompPos, Value); + AddCode8(0x75); + AddCode8(Value); } void CX86Ops::JnzLabel32(const char *Label, uint32_t Value) { CPU_Message(" jnz $%s", Label); - PUTDST16(m_RecompPos, 0x850F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x850F); + AddCode32(Value); } void CX86Ops::JsLabel32(const char *Label, uint32_t Value) { CPU_Message(" js $%s", Label); - PUTDST16(m_RecompPos, 0x880F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x880F); + AddCode32(Value); } void CX86Ops::JzLabel8(const char *Label, uint8_t Value) { CPU_Message(" jz $%s", Label); - PUTDST8(m_RecompPos, 0x74); - PUTDST8(m_RecompPos, Value); + AddCode8(0x74); + AddCode8(Value); } void CX86Ops::JzLabel32(const char *Label, uint32_t Value) { CPU_Message(" jz $%s", Label); - PUTDST16(m_RecompPos, 0x840F); - PUTDST32(m_RecompPos, Value); + AddCode16(0x840F); + AddCode32(Value); } void CX86Ops::LeaRegReg(x86Reg RegDest, x86Reg RegSrc, uint32_t Const, Multipler multiplier) @@ -662,10 +658,10 @@ void CX86Ops::LeaRegReg(x86Reg RegDest, x86Reg RegSrc, uint32_t Const, Multipler CPU_Message(" lea %s, [%s*%i]", x86_Name(RegDest), x86_Name(RegSrc), multiplier); } - PUTDST8(m_RecompPos, 0x8D); - PUTDST8(m_RecompPos, 0x04 + (RegDest * 8)); - PUTDST8(m_RecompPos, 0x05 + (RegSrc * 8) + CalcMultiplyCode(multiplier)); - PUTDST32(m_RecompPos, Const); + AddCode8(0x8D); + AddCode8((uint8_t)(0x04 + (RegDest * 8))); + AddCode8((uint8_t)(0x05 + (RegSrc * 8) + CalcMultiplyCode(multiplier))); + AddCode32(Const); } void CX86Ops::LeaRegReg2(x86Reg RegDest, x86Reg RegSrc, x86Reg RegSrc2, Multipler multiplier) @@ -677,9 +673,9 @@ void CX86Ops::LeaRegReg2(x86Reg RegDest, x86Reg RegSrc, x86Reg RegSrc2, Multiple g_Notify->BreakPoint(__FILE__, __LINE__); return; } - PUTDST8(m_RecompPos, 0x8D); - PUTDST8(m_RecompPos, 0x04 + (RegDest * 0x8)); - PUTDST8(m_RecompPos, 0x05 + (RegSrc * 0x8) + RegSrc2 + CalcMultiplyCode(multiplier)); + AddCode8(0x8D); + AddCode8((uint8_t)(0x04 + (RegDest * 0x8))); + AddCode8((uint8_t)(0x05 + (RegSrc * 0x8) + RegSrc2 + CalcMultiplyCode(multiplier))); } void CX86Ops::LeaSourceAndOffset(x86Reg x86DestReg, x86Reg x86SourceReg, int offset) @@ -717,8 +713,8 @@ void CX86Ops::LeaSourceAndOffset(x86Reg x86DestReg, x86Reg x86SourceReg, int off default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, offset); + AddCode16(x86Command); + AddCode32(offset); } else { @@ -748,8 +744,8 @@ void CX86Ops::LeaSourceAndOffset(x86Reg x86DestReg, x86Reg x86SourceReg, int off default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST8(m_RecompPos, offset); + AddCode16(x86Command); + AddCode8((uint8_t)offset); } } @@ -758,57 +754,57 @@ void CX86Ops::MoveConstByteToN64Mem(uint8_t Const, x86Reg AddrReg) CPU_Message(" mov byte ptr [%s+N64mem], %Xh", x86_Name(AddrReg), Const); switch (AddrReg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80C6); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83C6); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81C6); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82C6); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86C6); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87C6); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x84C6); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85C6); break; + case x86_EAX: AddCode16(0x80C6); break; + case x86_EBX: AddCode16(0x83C6); break; + case x86_ECX: AddCode16(0x81C6); break; + case x86_EDX: AddCode16(0x82C6); break; + case x86_ESI: AddCode16(0x86C6); break; + case x86_EDI: AddCode16(0x87C6); break; + case x86_ESP: AddCode16(0x84C6); break; + case x86_EBP: AddCode16(0x85C6); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); - PUTDST8(m_RecompPos, Const); + AddCode32((uint32_t)g_MMU->Rdram()); + AddCode8(Const); } void CX86Ops::MoveConstByteToVariable(uint8_t Const, void *Variable, const char * VariableName) { CPU_Message(" mov byte ptr [%s], %Xh", VariableName, Const); - PUTDST16(m_RecompPos, 0x05C6); - PUTDST32(m_RecompPos, Variable); - PUTDST8(m_RecompPos, Const); + AddCode16(0x05C6); + AddCode32((uint32_t)Variable); + AddCode8(Const); } void CX86Ops::MoveConstHalfToN64Mem(uint16_t Const, x86Reg AddrReg) { CPU_Message(" mov word ptr [%s+N64mem], %Xh", x86_Name(AddrReg), Const); - PUTDST8(m_RecompPos, 0x66); + AddCode8(0x66); switch (AddrReg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80C7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83C7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81C7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82C7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86C7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87C7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x84C7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85C7); break; + case x86_EAX: AddCode16(0x80C7); break; + case x86_EBX: AddCode16(0x83C7); break; + case x86_ECX: AddCode16(0x81C7); break; + case x86_EDX: AddCode16(0x82C7); break; + case x86_ESI: AddCode16(0x86C7); break; + case x86_EDI: AddCode16(0x87C7); break; + case x86_ESP: AddCode16(0x84C7); break; + case x86_EBP: AddCode16(0x85C7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); - PUTDST16(m_RecompPos, Const); + AddCode32((uint32_t)g_MMU->Rdram()); + AddCode16(Const); } void CX86Ops::MoveConstHalfToVariable(uint16_t Const, void *Variable, const char * VariableName) { CPU_Message(" mov word ptr [%s], %Xh", VariableName, Const); - PUTDST8(m_RecompPos, 0x66); - PUTDST16(m_RecompPos, 0x05C7); - PUTDST32(m_RecompPos, Variable); - PUTDST16(m_RecompPos, Const); + AddCode8(0x66); + AddCode16(0x05C7); + AddCode32((uint32_t)Variable); + AddCode16(Const); } void CX86Ops::MoveConstHalfToX86regPointer(uint16_t Const, x86Reg AddrReg1, x86Reg AddrReg2) @@ -817,8 +813,8 @@ void CX86Ops::MoveConstHalfToX86regPointer(uint16_t Const, x86Reg AddrReg1, x86R CPU_Message(" mov word ptr [%s+%s],%Xh", x86_Name(AddrReg1), x86_Name(AddrReg2), Const); - PUTDST8(m_RecompPos, 0x66); - PUTDST16(m_RecompPos, 0x04C7); + AddCode8(0x66); + AddCode16(0x04C7); switch (AddrReg1) { @@ -845,8 +841,8 @@ void CX86Ops::MoveConstHalfToX86regPointer(uint16_t Const, x86Reg AddrReg1, x86R default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); - PUTDST16(m_RecompPos, Const); + AddCode8(Param); + AddCode16(Const); } void CX86Ops::MoveConstToMemoryDisp(uint32_t Const, x86Reg AddrReg, uint32_t Disp) @@ -854,19 +850,19 @@ void CX86Ops::MoveConstToMemoryDisp(uint32_t Const, x86Reg AddrReg, uint32_t Dis CPU_Message(" mov dword ptr [%s+%Xh], %Xh", x86_Name(AddrReg), Disp, Const); switch (AddrReg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80C7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83C7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81C7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82C7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86C7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87C7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x84C7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85C7); break; + case x86_EAX: AddCode16(0x80C7); break; + case x86_EBX: AddCode16(0x83C7); break; + case x86_ECX: AddCode16(0x81C7); break; + case x86_EDX: AddCode16(0x82C7); break; + case x86_ESI: AddCode16(0x86C7); break; + case x86_EDI: AddCode16(0x87C7); break; + case x86_ESP: AddCode16(0x84C7); break; + case x86_EBP: AddCode16(0x85C7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Disp); - PUTDST32(m_RecompPos, Const); + AddCode32(Disp); + AddCode32(Const); } void CX86Ops::MoveConstToN64Mem(uint32_t Const, x86Reg AddrReg) @@ -874,19 +870,19 @@ void CX86Ops::MoveConstToN64Mem(uint32_t Const, x86Reg AddrReg) CPU_Message(" mov dword ptr [%s+N64mem], %Xh", x86_Name(AddrReg), Const); switch (AddrReg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80C7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83C7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81C7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82C7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86C7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87C7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x84C7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85C7); break; + case x86_EAX: AddCode16(0x80C7); break; + case x86_EBX: AddCode16(0x83C7); break; + case x86_ECX: AddCode16(0x81C7); break; + case x86_EDX: AddCode16(0x82C7); break; + case x86_ESI: AddCode16(0x86C7); break; + case x86_EDI: AddCode16(0x87C7); break; + case x86_ESP: AddCode16(0x84C7); break; + case x86_EBP: AddCode16(0x85C7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); - PUTDST32(m_RecompPos, Const); + AddCode32((uint32_t)g_MMU->Rdram()); + AddCode32(Const); } void CX86Ops::MoveConstToN64MemDisp(uint32_t Const, x86Reg AddrReg, uint8_t Disp) @@ -894,34 +890,34 @@ void CX86Ops::MoveConstToN64MemDisp(uint32_t Const, x86Reg AddrReg, uint8_t Disp CPU_Message(" mov dword ptr [%s+N64mem+%Xh], %Xh", x86_Name(AddrReg), Const, Disp); switch (AddrReg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80C7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83C7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81C7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82C7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86C7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87C7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x84C7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85C7); break; + case x86_EAX: AddCode16(0x80C7); break; + case x86_EBX: AddCode16(0x83C7); break; + case x86_ECX: AddCode16(0x81C7); break; + case x86_EDX: AddCode16(0x82C7); break; + case x86_ESI: AddCode16(0x86C7); break; + case x86_EDI: AddCode16(0x87C7); break; + case x86_ESP: AddCode16(0x84C7); break; + case x86_EBP: AddCode16(0x85C7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram() + Disp); - PUTDST32(m_RecompPos, Const); + AddCode32((uint32_t)g_MMU->Rdram() + Disp); + AddCode32(Const); } void CX86Ops::MoveConstToVariable(uint32_t Const, void *Variable, const char * VariableName) { CPU_Message(" mov dword ptr [%s], %Xh", VariableName, Const); - PUTDST16(m_RecompPos, 0x05C7); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x05C7); + AddCode32((uint32_t)Variable); + AddCode32(Const); } void CX86Ops::MoveConstToX86Pointer(uint32_t Const, x86Reg X86Pointer) { CPU_Message(" mov dword ptr [%s], %Xh", x86_Name(X86Pointer), Const); - PUTDST16(m_RecompPos, 0x00C7 + (X86Pointer * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0x00C7 + (X86Pointer * 0x100))); + AddCode32(Const); } void CX86Ops::MoveConstToX86reg(uint32_t Const, x86Reg reg) @@ -933,8 +929,8 @@ void CX86Ops::MoveConstToX86reg(uint32_t Const, x86Reg reg) else { CPU_Message(" mov %s, %Xh", x86_Name(reg), Const); - PUTDST16(m_RecompPos, 0xC0C7 + (reg * 0x100)); - PUTDST32(m_RecompPos, Const); + AddCode16((uint16_t)(0xC0C7 + (reg * 0x100))); + AddCode32(Const); } } @@ -944,7 +940,7 @@ void CX86Ops::MoveConstByteToX86regPointer(uint8_t Const, x86Reg AddrReg1, x86Re CPU_Message(" mov byte ptr [%s+%s],%Xh", x86_Name(AddrReg1), x86_Name(AddrReg2), Const); - PUTDST16(m_RecompPos, 0x04C6); + AddCode16(0x04C6); switch (AddrReg1) { @@ -971,8 +967,8 @@ void CX86Ops::MoveConstByteToX86regPointer(uint8_t Const, x86Reg AddrReg1, x86Re default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); - PUTDST8(m_RecompPos, Const); + AddCode8(Param); + AddCode8(Const); } void CX86Ops::MoveConstToX86regPointer(uint32_t Const, x86Reg AddrReg1, x86Reg AddrReg2) @@ -981,7 +977,7 @@ void CX86Ops::MoveConstToX86regPointer(uint32_t Const, x86Reg AddrReg1, x86Reg A CPU_Message(" mov dword ptr [%s+%s],%Xh", x86_Name(AddrReg1), x86_Name(AddrReg2), Const); - PUTDST16(m_RecompPos, 0x04C7); + AddCode16(0x04C7); switch (AddrReg1) { case x86_EAX: Param = 0x00; break; @@ -1006,8 +1002,8 @@ void CX86Ops::MoveConstToX86regPointer(uint32_t Const, x86Reg AddrReg1, x86Reg A default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); - PUTDST32(m_RecompPos, Const); + AddCode8(Param); + AddCode32(Const); } void CX86Ops::MoveN64MemDispToX86reg(x86Reg reg, x86Reg AddrReg, uint8_t Disp) @@ -1039,8 +1035,8 @@ void CX86Ops::MoveN64MemDispToX86reg(x86Reg reg, x86Reg AddrReg, uint8_t Disp) case x86_ESP: x86Command += 0xA000; break; case x86_EBP: x86Command += 0xA800; break; } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram() + Disp); + AddCode16(x86Command); + AddCode32((uint32_t)(g_MMU->Rdram() + Disp)); } void CX86Ops::MoveN64MemToX86reg(x86Reg reg, x86Reg AddrReg) @@ -1073,8 +1069,8 @@ void CX86Ops::MoveN64MemToX86reg(x86Reg reg, x86Reg AddrReg) case x86_ESP: x86Command += 0xA000; break; case x86_EBP: x86Command += 0xA800; break; } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveN64MemToX86regByte(x86Reg reg, x86Reg AddrReg) @@ -1108,8 +1104,8 @@ void CX86Ops::MoveN64MemToX86regByte(x86Reg reg, x86Reg AddrReg) g_Notify->BreakPoint(__FILE__, __LINE__); break; } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) @@ -1118,7 +1114,7 @@ void CX86Ops::MoveN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) CPU_Message(" mov %s, word ptr [%s+N64mem]", x86_HalfName(reg), x86_Name(AddrReg)); - PUTDST8(m_RecompPos, 0x66); + AddCode8(0x66); switch (AddrReg) { case x86_EAX: x86Command = 0x008B; break; @@ -1143,8 +1139,8 @@ void CX86Ops::MoveN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) case x86_ESP: x86Command += 0xA000; break; case x86_EBP: x86Command += 0xA800; break; } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveSxByteX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg reg) @@ -1153,17 +1149,17 @@ void CX86Ops::MoveSxByteX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, CPU_Message(" movsx %s, byte ptr [%s+%s]", x86_Name(reg), x86_Name(AddrReg1), x86_Name(AddrReg2)); - PUTDST16(m_RecompPos, 0xBE0F); + AddCode16(0xBE0F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x04); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1C); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0C); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x14); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x34); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3C); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x24); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2C); break; + case x86_EAX: AddCode8(0x04); break; + case x86_EBX: AddCode8(0x1C); break; + case x86_ECX: AddCode8(0x0C); break; + case x86_EDX: AddCode8(0x14); break; + case x86_ESI: AddCode8(0x34); break; + case x86_EDI: AddCode8(0x3C); break; + case x86_ESP: AddCode8(0x24); break; + case x86_EBP: AddCode8(0x2C); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1193,7 +1189,7 @@ void CX86Ops::MoveSxByteX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveSxHalfX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg reg) @@ -1202,17 +1198,17 @@ void CX86Ops::MoveSxHalfX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, CPU_Message(" movsx %s, word ptr [%s+%s]", x86_Name(reg), x86_Name(AddrReg1), x86_Name(AddrReg2)); - PUTDST16(m_RecompPos, 0xBF0F); + AddCode16(0xBF0F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x04); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1C); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0C); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x14); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x34); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3C); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x24); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2C); break; + case x86_EAX: AddCode8(0x04); break; + case x86_EBX: AddCode8(0x1C); break; + case x86_ECX: AddCode8(0x0C); break; + case x86_EDX: AddCode8(0x14); break; + case x86_ESI: AddCode8(0x34); break; + case x86_EDI: AddCode8(0x3C); break; + case x86_ESP: AddCode8(0x24); break; + case x86_EBP: AddCode8(0x2C); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1242,7 +1238,7 @@ void CX86Ops::MoveSxHalfX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveSxN64MemToX86regByte(x86Reg reg, x86Reg AddrReg) @@ -1277,9 +1273,9 @@ void CX86Ops::MoveSxN64MemToX86regByte(x86Reg reg, x86Reg AddrReg) g_Notify->BreakPoint(__FILE__, __LINE__); break; } - PUTDST8(m_RecompPos, 0x0f); - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode8(0x0f); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveSxN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) @@ -1313,53 +1309,53 @@ void CX86Ops::MoveSxN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) case x86_EBP: x86Command += 0xA800; break; } - PUTDST8(m_RecompPos, 0x0f); - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode8(0x0f); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveSxVariableToX86regByte(void *Variable, const char * VariableName, x86Reg reg) { CPU_Message(" movsx %s, byte ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0xbe0f); + AddCode16(0xbe0f); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x05); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1D); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0D); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x15); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x35); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3D); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x25); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2D); break; + case x86_EAX: AddCode8(0x05); break; + case x86_EBX: AddCode8(0x1D); break; + case x86_ECX: AddCode8(0x0D); break; + case x86_EDX: AddCode8(0x15); break; + case x86_ESI: AddCode8(0x35); break; + case x86_EDI: AddCode8(0x3D); break; + case x86_ESP: AddCode8(0x25); break; + case x86_EBP: AddCode8(0x2D); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveSxVariableToX86regHalf(void *Variable, const char * VariableName, x86Reg reg) { CPU_Message(" movsx %s, word ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0xbf0f); + AddCode16(0xbf0f); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x05); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1D); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0D); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x15); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x35); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3D); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x25); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2D); break; + case x86_EAX: AddCode8(0x05); break; + case x86_EBX: AddCode8(0x1D); break; + case x86_ECX: AddCode8(0x0D); break; + case x86_EDX: AddCode8(0x15); break; + case x86_ESI: AddCode8(0x35); break; + case x86_EDI: AddCode8(0x3D); break; + case x86_ESP: AddCode8(0x25); break; + case x86_EBP: AddCode8(0x2D); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveVariableToX86reg(void *Variable, const char * VariableName, x86Reg reg) @@ -1367,18 +1363,18 @@ void CX86Ops::MoveVariableToX86reg(void *Variable, const char * VariableName, x8 CPU_Message(" mov %s, dword ptr [%s]", x86_Name(reg), VariableName); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x058B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D8B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D8B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x158B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x358B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D8B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x258B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D8B); break; + case x86_EAX: AddCode16(0x058B); break; + case x86_EBX: AddCode16(0x1D8B); break; + case x86_ECX: AddCode16(0x0D8B); break; + case x86_EDX: AddCode16(0x158B); break; + case x86_ESI: AddCode16(0x358B); break; + case x86_EDI: AddCode16(0x3D8B); break; + case x86_ESP: AddCode16(0x258B); break; + case x86_EBP: AddCode16(0x2D8B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveVariableDispToX86Reg(void *Variable, const char * VariableName, x86Reg reg, x86Reg AddrReg, int Multiplier) @@ -1386,18 +1382,18 @@ void CX86Ops::MoveVariableDispToX86Reg(void *Variable, const char * VariableName int x = 0; CPU_Message(" mov %s, dword ptr [%s+%s*%i]", x86_Name(reg), VariableName, x86_Name(AddrReg), Multiplier); - PUTDST8(m_RecompPos, 0x8B); + AddCode8(0x8B); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x04); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1C); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0C); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x14); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x34); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3C); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x24); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2C); break; + case x86_EAX: AddCode8(0x04); break; + case x86_EBX: AddCode8(0x1C); break; + case x86_ECX: AddCode8(0x0C); break; + case x86_EDX: AddCode8(0x14); break; + case x86_ESI: AddCode8(0x34); break; + case x86_EDI: AddCode8(0x3C); break; + case x86_ESP: AddCode8(0x24); break; + case x86_EBP: AddCode8(0x2C); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1416,19 +1412,19 @@ void CX86Ops::MoveVariableDispToX86Reg(void *Variable, const char * VariableName /* format xx|000000 */ switch (AddrReg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x05 | x); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1D | x); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0D | x); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x15 | x); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x35 | x); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3D | x); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x25 | x); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2D | x); break; + case x86_EAX: AddCode8((uint8_t)(0x05 | x)); break; + case x86_EBX: AddCode8((uint8_t)(0x1D | x)); break; + case x86_ECX: AddCode8((uint8_t)(0x0D | x)); break; + case x86_EDX: AddCode8((uint8_t)(0x15 | x)); break; + case x86_ESI: AddCode8((uint8_t)(0x35 | x)); break; + case x86_EDI: AddCode8((uint8_t)(0x3D | x)); break; + case x86_ESP: AddCode8((uint8_t)(0x25 | x)); break; + case x86_EBP: AddCode8((uint8_t)(0x2D | x)); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveVariableToX86regByte(void *Variable, const char * VariableName, x86Reg reg) @@ -1437,35 +1433,35 @@ void CX86Ops::MoveVariableToX86regByte(void *Variable, const char * VariableName switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x058A); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D8A); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D8A); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x158A); break; + case x86_EAX: AddCode16(0x058A); break; + case x86_EBX: AddCode16(0x1D8A); break; + case x86_ECX: AddCode16(0x0D8A); break; + case x86_EDX: AddCode16(0x158A); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveVariableToX86regHalf(void *Variable, const char * VariableName, x86Reg reg) { CPU_Message(" mov %s, word ptr [%s]", x86_HalfName(reg), VariableName); - PUTDST8(m_RecompPos, 0x66); + AddCode8(0x66); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x058B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D8B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D8B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x158B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x358B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D8B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x258B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D8B); break; + case x86_EAX: AddCode16(0x058B); break; + case x86_EBX: AddCode16(0x1D8B); break; + case x86_ECX: AddCode16(0x0D8B); break; + case x86_EDX: AddCode16(0x158B); break; + case x86_ESI: AddCode16(0x358B); break; + case x86_EDI: AddCode16(0x3D8B); break; + case x86_ESP: AddCode16(0x258B); break; + case x86_EBP: AddCode16(0x2D8B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveX86regByteToN64Mem(x86Reg reg, x86Reg AddrReg) @@ -1495,8 +1491,8 @@ void CX86Ops::MoveX86regByteToN64Mem(x86Reg reg, x86Reg AddrReg) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveX86regByteToVariable(x86Reg reg, void * Variable, const char * VariableName) @@ -1505,14 +1501,14 @@ void CX86Ops::MoveX86regByteToVariable(x86Reg reg, void * Variable, const char * switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0588); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D88); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D88); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1588); break; + case x86_EAX: AddCode16(0x0588); break; + case x86_EBX: AddCode16(0x1D88); break; + case x86_ECX: AddCode16(0x0D88); break; + case x86_EDX: AddCode16(0x1588); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveX86regByteToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg AddrReg2) @@ -1523,14 +1519,14 @@ void CX86Ops::MoveX86regByteToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0488); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1C88); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0C88); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1488); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3488); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3C88); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2488); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2C88); break; + case x86_EAX: AddCode16(0x0488); break; + case x86_EBX: AddCode16(0x1C88); break; + case x86_ECX: AddCode16(0x0C88); break; + case x86_EDX: AddCode16(0x1488); break; + case x86_ESI: AddCode16(0x3488); break; + case x86_EDI: AddCode16(0x3C88); break; + case x86_ESP: AddCode16(0x2488); break; + case x86_EBP: AddCode16(0x2C88); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1560,7 +1556,7 @@ void CX86Ops::MoveX86regByteToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveX86regHalfToN64Mem(x86Reg reg, x86Reg AddrReg) @@ -1569,7 +1565,7 @@ void CX86Ops::MoveX86regHalfToN64Mem(x86Reg reg, x86Reg AddrReg) CPU_Message(" mov word ptr [%s+N64mem], %s", x86_Name(AddrReg), x86_HalfName(reg)); - PUTDST8(m_RecompPos, 0x66); + AddCode8(0x66); switch (AddrReg) { case x86_EAX: x86Command = 0x0089; break; @@ -1596,28 +1592,28 @@ void CX86Ops::MoveX86regHalfToN64Mem(x86Reg reg, x86Reg AddrReg) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveX86regHalfToVariable(x86Reg reg, void * Variable, const char * VariableName) { CPU_Message(" mov word ptr [%s], %s", VariableName, x86_HalfName(reg)); - PUTDST8(m_RecompPos, 0x66); + AddCode8(0x66); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0589); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D89); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D89); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1589); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3589); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D89); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2589); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D89); break; + case x86_EAX: AddCode16(0x0589); break; + case x86_EBX: AddCode16(0x1D89); break; + case x86_ECX: AddCode16(0x0D89); break; + case x86_EDX: AddCode16(0x1589); break; + case x86_ESI: AddCode16(0x3589); break; + case x86_EDI: AddCode16(0x3D89); break; + case x86_ESP: AddCode16(0x2589); break; + case x86_EBP: AddCode16(0x2D89); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::MoveX86regHalfToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg AddrReg2) @@ -1626,17 +1622,17 @@ void CX86Ops::MoveX86regHalfToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg CPU_Message(" mov word ptr [%s+%s],%s", x86_Name(AddrReg1), x86_Name(AddrReg2), x86_HalfName(reg)); - PUTDST8(m_RecompPos, 0x66); + AddCode8(0x66); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0489); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1C89); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0C89); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1489); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3489); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3C89); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2489); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2C89); break; + case x86_EAX: AddCode16(0x0489); break; + case x86_EBX: AddCode16(0x1C89); break; + case x86_ECX: AddCode16(0x0C89); break; + case x86_EDX: AddCode16(0x1489); break; + case x86_ESI: AddCode16(0x3489); break; + case x86_EDI: AddCode16(0x3C89); break; + case x86_ESP: AddCode16(0x2489); break; + case x86_EBP: AddCode16(0x2C89); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1666,7 +1662,7 @@ void CX86Ops::MoveX86regHalfToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveX86PointerToX86reg(x86Reg reg, x86Reg X86Pointer) @@ -1700,7 +1696,7 @@ void CX86Ops::MoveX86PointerToX86reg(x86Reg reg, x86Reg X86Pointer) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::MoveX86PointerToX86regDisp(x86Reg reg, x86Reg X86Pointer, uint8_t Disp) @@ -1734,8 +1730,8 @@ void CX86Ops::MoveX86PointerToX86regDisp(x86Reg reg, x86Reg X86Pointer, uint8_t default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST8(m_RecompPos, Disp); + AddCode16(x86Command); + AddCode8(Disp); } void CX86Ops::MoveX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg reg) @@ -1746,14 +1742,14 @@ void CX86Ops::MoveX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x048B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1C8B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0C8B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x148B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x348B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3C8B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x248B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2C8B); break; + case x86_EAX: AddCode16(0x048B); break; + case x86_EBX: AddCode16(0x1C8B); break; + case x86_ECX: AddCode16(0x0C8B); break; + case x86_EDX: AddCode16(0x148B); break; + case x86_ESI: AddCode16(0x348B); break; + case x86_EDI: AddCode16(0x3C8B); break; + case x86_ESP: AddCode16(0x248B); break; + case x86_EBP: AddCode16(0x2C8B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1783,7 +1779,7 @@ void CX86Ops::MoveX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveX86regPointerToX86regDisp8(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg reg, uint8_t offset) @@ -1794,14 +1790,14 @@ void CX86Ops::MoveX86regPointerToX86regDisp8(x86Reg AddrReg1, x86Reg AddrReg2, x switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x448B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x5C8B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x4C8B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x548B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x748B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x7C8B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x648B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x6C8B); break; + case x86_EAX: AddCode16(0x448B); break; + case x86_EBX: AddCode16(0x5C8B); break; + case x86_ECX: AddCode16(0x4C8B); break; + case x86_EDX: AddCode16(0x548B); break; + case x86_ESI: AddCode16(0x748B); break; + case x86_EDI: AddCode16(0x7C8B); break; + case x86_ESP: AddCode16(0x648B); break; + case x86_EBP: AddCode16(0x6C8B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -1831,8 +1827,8 @@ void CX86Ops::MoveX86regPointerToX86regDisp8(x86Reg AddrReg1, x86Reg AddrReg2, x default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); - PUTDST8(m_RecompPos, offset); + AddCode8(Param); + AddCode8(offset); } void CX86Ops::MoveX86regToMemory(x86Reg reg, x86Reg AddrReg, uint32_t Disp) @@ -1866,8 +1862,8 @@ void CX86Ops::MoveX86regToMemory(x86Reg reg, x86Reg AddrReg, uint32_t Disp) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, Disp); + AddCode16(x86Command); + AddCode32(Disp); } void CX86Ops::MoveX86regToN64Mem(x86Reg reg, x86Reg AddrReg) @@ -1901,8 +1897,8 @@ void CX86Ops::MoveX86regToN64Mem(x86Reg reg, x86Reg AddrReg) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode16(x86Command); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::MoveX86regToN64MemDisp(x86Reg reg, x86Reg AddrReg, uint8_t Disp) @@ -1936,8 +1932,8 @@ void CX86Ops::MoveX86regToN64MemDisp(x86Reg reg, x86Reg AddrReg, uint8_t Disp) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram() + Disp); + AddCode16(x86Command); + AddCode32((uint32_t)(g_MMU->Rdram() + Disp)); } void CX86Ops::MoveX86regToVariable(x86Reg reg, void * Variable, const char * VariableName) @@ -1945,18 +1941,18 @@ void CX86Ops::MoveX86regToVariable(x86Reg reg, void * Variable, const char * Var CPU_Message(" mov dword ptr [%s], %s", VariableName, x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0589); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D89); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D89); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1589); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3589); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D89); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2589); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D89); break; + case x86_EAX: AddCode16(0x0589); break; + case x86_EBX: AddCode16(0x1D89); break; + case x86_ECX: AddCode16(0x0D89); break; + case x86_EDX: AddCode16(0x1589); break; + case x86_ESI: AddCode16(0x3589); break; + case x86_EDI: AddCode16(0x3D89); break; + case x86_ESP: AddCode16(0x2589); break; + case x86_EBP: AddCode16(0x2D89); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)(Variable)); } void CX86Ops::MoveX86RegToX86Reg(x86Reg Source, x86Reg Destination) @@ -1996,7 +1992,7 @@ void CX86Ops::MoveX86RegToX86Reg(x86Reg Source, x86Reg Destination) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::MoveX86regToX86Pointer(x86Reg reg, x86Reg X86Pointer) @@ -2030,7 +2026,7 @@ void CX86Ops::MoveX86regToX86Pointer(x86Reg reg, x86Reg X86Pointer) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::MoveX86regToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg AddrReg2) @@ -2041,14 +2037,14 @@ void CX86Ops::MoveX86regToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg Addr switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0489); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1C89); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0C89); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1489); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3489); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3C89); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2489); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2C89); break; + case x86_EAX: AddCode16(0x0489); break; + case x86_EBX: AddCode16(0x1C89); break; + case x86_ECX: AddCode16(0x0C89); break; + case x86_EDX: AddCode16(0x1489); break; + case x86_ESI: AddCode16(0x3489); break; + case x86_EDI: AddCode16(0x3C89); break; + case x86_ESP: AddCode16(0x2489); break; + case x86_EBP: AddCode16(0x2C89); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2078,7 +2074,7 @@ void CX86Ops::MoveX86regToX86regPointer(x86Reg reg, x86Reg AddrReg1, x86Reg Addr default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveZxByteX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg reg) @@ -2087,17 +2083,17 @@ void CX86Ops::MoveZxByteX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, CPU_Message(" movzx %s, byte ptr [%s+%s]", x86_Name(reg), x86_Name(AddrReg1), x86_Name(AddrReg2)); - PUTDST16(m_RecompPos, 0xB60F); + AddCode16(0xB60F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x04); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1C); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0C); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x14); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x34); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3C); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x24); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2C); break; + case x86_EAX: AddCode8(0x04); break; + case x86_EBX: AddCode8(0x1C); break; + case x86_ECX: AddCode8(0x0C); break; + case x86_EDX: AddCode8(0x14); break; + case x86_ESI: AddCode8(0x34); break; + case x86_EDI: AddCode8(0x3C); break; + case x86_ESP: AddCode8(0x24); break; + case x86_EBP: AddCode8(0x2C); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2127,7 +2123,7 @@ void CX86Ops::MoveZxByteX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveZxHalfX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, x86Reg reg) @@ -2136,17 +2132,17 @@ void CX86Ops::MoveZxHalfX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, CPU_Message(" movzx %s, word ptr [%s+%s]", x86_Name(reg), x86_Name(AddrReg1), x86_Name(AddrReg2)); - PUTDST16(m_RecompPos, 0xB70F); + AddCode16(0xB70F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x04); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1C); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0C); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x14); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x34); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3C); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x24); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2C); break; + case x86_EAX: AddCode8(0x04); break; + case x86_EBX: AddCode8(0x1C); break; + case x86_ECX: AddCode8(0x0C); break; + case x86_EDX: AddCode8(0x14); break; + case x86_ESI: AddCode8(0x34); break; + case x86_EDI: AddCode8(0x3C); break; + case x86_ESP: AddCode8(0x24); break; + case x86_EBP: AddCode8(0x2C); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2176,7 +2172,7 @@ void CX86Ops::MoveZxHalfX86regPointerToX86reg(x86Reg AddrReg1, x86Reg AddrReg2, default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Param); + AddCode8(Param); } void CX86Ops::MoveZxN64MemToX86regByte(x86Reg reg, x86Reg AddrReg) @@ -2211,9 +2207,9 @@ void CX86Ops::MoveZxN64MemToX86regByte(x86Reg reg, x86Reg AddrReg) g_Notify->BreakPoint(__FILE__, __LINE__); break; } - PUTDST8(m_RecompPos, 0x0f); - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode8(0x0f); + AddCode16(x86Command); + AddCode32((uint32_t)(g_MMU->Rdram())); } void CX86Ops::MoveZxN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) @@ -2249,53 +2245,53 @@ void CX86Ops::MoveZxN64MemToX86regHalf(x86Reg reg, x86Reg AddrReg) g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, 0x0f); - PUTDST16(m_RecompPos, x86Command); - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode8(0x0f); + AddCode16(x86Command); + AddCode32((uint32_t)(g_MMU->Rdram())); } void CX86Ops::MoveZxVariableToX86regByte(void *Variable, const char * VariableName, x86Reg reg) { CPU_Message(" movzx %s, byte ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0xb60f); + AddCode16(0xb60f); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x05); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1D); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0D); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x15); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x35); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3D); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x25); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2D); break; + case x86_EAX: AddCode8(0x05); break; + case x86_EBX: AddCode8(0x1D); break; + case x86_ECX: AddCode8(0x0D); break; + case x86_EDX: AddCode8(0x15); break; + case x86_ESI: AddCode8(0x35); break; + case x86_EDI: AddCode8(0x3D); break; + case x86_ESP: AddCode8(0x25); break; + case x86_EBP: AddCode8(0x2D); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)(Variable)); } void CX86Ops::MoveZxVariableToX86regHalf(void *Variable, const char * VariableName, x86Reg reg) { CPU_Message(" movzx %s, word ptr [%s]", x86_Name(reg), VariableName); - PUTDST16(m_RecompPos, 0xb70f); + AddCode16(0xb70f); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x05); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x1D); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x0D); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x15); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x35); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x3D); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x25); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x2D); break; + case x86_EAX: AddCode8(0x05); break; + case x86_EBX: AddCode8(0x1D); break; + case x86_ECX: AddCode8(0x0D); break; + case x86_EDX: AddCode8(0x15); break; + case x86_ESI: AddCode8(0x35); break; + case x86_EDI: AddCode8(0x3D); break; + case x86_ESP: AddCode8(0x25); break; + case x86_EBP: AddCode8(0x2D); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)(Variable)); } void CX86Ops::MulX86reg(x86Reg reg) @@ -2303,14 +2299,14 @@ void CX86Ops::MulX86reg(x86Reg reg) CPU_Message(" mul %s", x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE0F7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xE3F7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE1F7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xE2F7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xE6F7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xE7F7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xE4F7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xE5F7); break; + case x86_EAX: AddCode16(0xE0F7); break; + case x86_EBX: AddCode16(0xE3F7); break; + case x86_ECX: AddCode16(0xE1F7); break; + case x86_EDX: AddCode16(0xE2F7); break; + case x86_ESI: AddCode16(0xE6F7); break; + case x86_EDI: AddCode16(0xE7F7); break; + case x86_ESP: AddCode16(0xE4F7); break; + case x86_EBP: AddCode16(0xE5F7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2321,14 +2317,14 @@ void CX86Ops::NotX86Reg(x86Reg reg) CPU_Message(" not %s", x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xD0F7); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xD3F7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xD1F7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xD2F7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xD6F7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xD7F7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xD4F7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xD5F7); break; + case x86_EAX: AddCode16(0xD0F7); break; + case x86_EBX: AddCode16(0xD3F7); break; + case x86_ECX: AddCode16(0xD1F7); break; + case x86_EDX: AddCode16(0xD2F7); break; + case x86_ESI: AddCode16(0xD6F7); break; + case x86_EDI: AddCode16(0xD7F7); break; + case x86_ESP: AddCode16(0xD4F7); break; + case x86_EBP: AddCode16(0xD5F7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2337,9 +2333,9 @@ void CX86Ops::NotX86Reg(x86Reg reg) void CX86Ops::OrConstToVariable(uint32_t Const, void * Variable, const char * VariableName) { CPU_Message(" or dword ptr [%s], 0x%X", VariableName, Const); - PUTDST16(m_RecompPos, 0x0D81); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x0D81); + AddCode32((uint32_t)(Variable)); + AddCode32(Const); } void CX86Ops::OrConstToX86Reg(uint32_t Const, x86Reg reg) @@ -2348,35 +2344,35 @@ void CX86Ops::OrConstToX86Reg(uint32_t Const, x86Reg reg) if ((Const & 0xFFFFFF80) != 0 && (Const & 0xFFFFFF80) != 0xFFFFFF80) { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xC881); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xCB81); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xC981); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xCA81); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xCE81); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xCF81); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xCC81); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xCD81); break; + case x86_EAX: AddCode16(0xC881); break; + case x86_EBX: AddCode16(0xCB81); break; + case x86_ECX: AddCode16(0xC981); break; + case x86_EDX: AddCode16(0xCA81); break; + case x86_ESI: AddCode16(0xCE81); break; + case x86_EDI: AddCode16(0xCF81); break; + case x86_ESP: AddCode16(0xCC81); break; + case x86_EBP: AddCode16(0xCD81); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Const); + AddCode32(Const); } else { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xC883); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xCB83); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xC983); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xCA83); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xCE83); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xCF83); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xCC83); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xCD83); break; + case x86_EAX: AddCode16(0xC883); break; + case x86_EBX: AddCode16(0xCB83); break; + case x86_ECX: AddCode16(0xC983); break; + case x86_EDX: AddCode16(0xCA83); break; + case x86_ESI: AddCode16(0xCE83); break; + case x86_EDI: AddCode16(0xCF83); break; + case x86_ESP: AddCode16(0xCC83); break; + case x86_EBP: AddCode16(0xCD83); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Const); + AddCode8((uint8_t)Const); } } @@ -2385,18 +2381,18 @@ void CX86Ops::OrVariableToX86Reg(void * Variable, const char * VariableName, x86 CPU_Message(" or %s, dword ptr [%s]", x86_Name(reg), VariableName); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x050B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D0B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D0B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x150B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x350B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D0B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x250B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D0B); break; + case x86_EAX: AddCode16(0x050B); break; + case x86_EBX: AddCode16(0x1D0B); break; + case x86_ECX: AddCode16(0x0D0B); break; + case x86_EDX: AddCode16(0x150B); break; + case x86_ESI: AddCode16(0x350B); break; + case x86_EDI: AddCode16(0x3D0B); break; + case x86_ESP: AddCode16(0x250B); break; + case x86_EBP: AddCode16(0x2D0B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)(Variable)); } void CX86Ops::OrX86RegToVariable(void * Variable, const char * VariableName, x86Reg reg) @@ -2404,18 +2400,18 @@ void CX86Ops::OrX86RegToVariable(void * Variable, const char * VariableName, x86 CPU_Message(" or dword ptr [%s], %s", VariableName, x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0509); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D09); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D09); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1509); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3509); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D09); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2509); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D09); break; + case x86_EAX: AddCode16(0x0509); break; + case x86_EBX: AddCode16(0x1D09); break; + case x86_ECX: AddCode16(0x0D09); break; + case x86_EDX: AddCode16(0x1509); break; + case x86_ESI: AddCode16(0x3509); break; + case x86_EDI: AddCode16(0x3D09); break; + case x86_ESP: AddCode16(0x2509); break; + case x86_EBP: AddCode16(0x2D09); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)(Variable)); } void CX86Ops::OrX86RegToX86Reg(x86Reg Destination, x86Reg Source) @@ -2449,19 +2445,19 @@ void CX86Ops::OrX86RegToX86Reg(x86Reg Destination, x86Reg Source) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::Popad(void) { CPU_Message(" popad"); - PUTDST8(m_RecompPos, 0x61); + AddCode8(0x61); } void CX86Ops::Pushad(void) { CPU_Message(" pushad"); - PUTDST8(m_RecompPos, 0x60); + AddCode8(0x60); } void CX86Ops::Push(x86Reg reg) @@ -2470,14 +2466,14 @@ void CX86Ops::Push(x86Reg reg) switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x50); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x53); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x51); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x52); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x56); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x57); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x54); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x55); break; + case x86_EAX: AddCode8(0x50); break; + case x86_EBX: AddCode8(0x53); break; + case x86_ECX: AddCode8(0x51); break; + case x86_EDX: AddCode8(0x52); break; + case x86_ESI: AddCode8(0x56); break; + case x86_EDI: AddCode8(0x57); break; + case x86_ESP: AddCode8(0x54); break; + case x86_EBP: AddCode8(0x55); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2489,14 +2485,14 @@ void CX86Ops::Pop(x86Reg reg) switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x58); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x5B); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x59); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x5A); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x5E); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x5F); break; - case x86_ESP: PUTDST8(m_RecompPos, 0x5C); break; - case x86_EBP: PUTDST8(m_RecompPos, 0x5D); break; + case x86_EAX: AddCode8(0x58); break; + case x86_EBX: AddCode8(0x5B); break; + case x86_ECX: AddCode8(0x59); break; + case x86_EDX: AddCode8(0x5A); break; + case x86_ESI: AddCode8(0x5E); break; + case x86_EDI: AddCode8(0x5F); break; + case x86_ESP: AddCode8(0x5C); break; + case x86_EBP: AddCode8(0x5D); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2504,31 +2500,38 @@ void CX86Ops::Pop(x86Reg reg) void CX86Ops::PushImm32(uint32_t Value) { - PushImm32(stdstr_f("%d", Value).c_str(), Value); + if ((Value & 0xFFFFF000) != 0) + { + PushImm32(stdstr_f("0x%X", Value).c_str(), Value); + } + else + { + PushImm32(stdstr_f("%d", Value).c_str(), Value); + } } void CX86Ops::PushImm32(const char * String, uint32_t Value) { CPU_Message(" push %s", String); - PUTDST8(m_RecompPos, 0x68); - PUTDST32(m_RecompPos, Value); + AddCode8(0x68); + AddCode32(Value); } void CX86Ops::Ret(void) { CPU_Message(" ret"); - PUTDST8(m_RecompPos, 0xC3); + AddCode8(0xC3); } void CX86Ops::Seta(x86Reg reg) { CPU_Message(" seta %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x970F); + AddCode16(0x970F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2537,21 +2540,21 @@ void CX86Ops::Seta(x86Reg reg) void CX86Ops::SetaVariable(void * Variable, const char * VariableName) { CPU_Message(" seta byte ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x970F); - PUTDST8(m_RecompPos, 0x05); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x970F); + AddCode8(0x05); + AddCode32((uint32_t)(Variable)); } void CX86Ops::Setae(x86Reg reg) { CPU_Message(" setae %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x930F); + AddCode16(0x930F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2560,13 +2563,13 @@ void CX86Ops::Setae(x86Reg reg) void CX86Ops::Setb(x86Reg reg) { CPU_Message(" setb %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x920F); + AddCode16(0x920F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2575,21 +2578,21 @@ void CX86Ops::Setb(x86Reg reg) void CX86Ops::SetbVariable(void * Variable, const char * VariableName) { CPU_Message(" setb byte ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x920F); - PUTDST8(m_RecompPos, 0x05); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x920F); + AddCode8(0x05); + AddCode32((uint32_t)(Variable)); } void CX86Ops::Setg(x86Reg reg) { CPU_Message(" setg %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x9F0F); + AddCode16(0x9F0F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2598,21 +2601,21 @@ void CX86Ops::Setg(x86Reg reg) void CX86Ops::SetgVariable(void * Variable, const char * VariableName) { CPU_Message(" setg byte ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x9F0F); - PUTDST8(m_RecompPos, 0x05); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x9F0F); + AddCode8(0x05); + AddCode32((uint32_t)Variable); } void CX86Ops::Setl(x86Reg reg) { CPU_Message(" setl %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x9C0F); + AddCode16(0x9C0F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2621,21 +2624,21 @@ void CX86Ops::Setl(x86Reg reg) void CX86Ops::SetlVariable(void * Variable, const char * VariableName) { CPU_Message(" setl byte ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x9C0F); - PUTDST8(m_RecompPos, 0x05); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x9C0F); + AddCode8(0x05); + AddCode32((uint32_t)Variable); } void CX86Ops::Setz(x86Reg reg) { CPU_Message(" setz %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x940F); + AddCode16(0x940F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2644,13 +2647,13 @@ void CX86Ops::Setz(x86Reg reg) void CX86Ops::Setnz(x86Reg reg) { CPU_Message(" setnz %s", x86_ByteName(reg)); - PUTDST16(m_RecompPos, 0x950F); + AddCode16(0x950F); switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xC0); break; - case x86_EBX: PUTDST8(m_RecompPos, 0xC3); break; - case x86_ECX: PUTDST8(m_RecompPos, 0xC1); break; - case x86_EDX: PUTDST8(m_RecompPos, 0xC2); break; + case x86_EAX: AddCode8(0xC0); break; + case x86_EBX: AddCode8(0xC3); break; + case x86_ECX: AddCode8(0xC1); break; + case x86_EDX: AddCode8(0xC2); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2661,7 +2664,7 @@ void CX86Ops::ShiftLeftDouble(x86Reg Destination, x86Reg Source) uint8_t s = 0xC0; CPU_Message(" shld %s, %s, cl", x86_Name(Destination), x86_Name(Source)); - PUTDST16(m_RecompPos, 0xA50F); + AddCode16(0xA50F); switch (Destination) { @@ -2691,7 +2694,7 @@ void CX86Ops::ShiftLeftDouble(x86Reg Destination, x86Reg Source) g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, s); + AddCode8(s); } void CX86Ops::ShiftLeftDoubleImmed(x86Reg Destination, x86Reg Source, uint8_t Immediate) @@ -2699,7 +2702,7 @@ void CX86Ops::ShiftLeftDoubleImmed(x86Reg Destination, x86Reg Source, uint8_t Im uint8_t s = 0xC0; CPU_Message(" shld %s, %s, %Xh", x86_Name(Destination), x86_Name(Source), Immediate); - PUTDST16(m_RecompPos, 0xA40F); + AddCode16(0xA40F); switch (Destination) { @@ -2729,8 +2732,8 @@ void CX86Ops::ShiftLeftDoubleImmed(x86Reg Destination, x86Reg Source, uint8_t Im g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, s); - PUTDST8(m_RecompPos, Immediate); + AddCode8(s); + AddCode8(Immediate); } void CX86Ops::ShiftLeftSign(x86Reg reg) @@ -2738,14 +2741,14 @@ void CX86Ops::ShiftLeftSign(x86Reg reg) CPU_Message(" shl %s, cl", x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE0D3); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xE3D3); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE1D3); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xE2D3); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xE6D3); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xE7D3); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xE4D3); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xE5D3); break; + case x86_EAX: AddCode16(0xE0D3); break; + case x86_EBX: AddCode16(0xE3D3); break; + case x86_ECX: AddCode16(0xE1D3); break; + case x86_EDX: AddCode16(0xE2D3); break; + case x86_ESI: AddCode16(0xE6D3); break; + case x86_EDI: AddCode16(0xE7D3); break; + case x86_ESP: AddCode16(0xE4D3); break; + case x86_EBP: AddCode16(0xE5D3); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2756,18 +2759,18 @@ void CX86Ops::ShiftLeftSignImmed(x86Reg reg, uint8_t Immediate) CPU_Message(" shl %s, %Xh", x86_Name(reg), Immediate); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE0C1); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xE3C1); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE1C1); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xE2C1); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xE6C1); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xE7C1); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xE4C1); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xE5C1); break; + case x86_EAX: AddCode16(0xE0C1); break; + case x86_EBX: AddCode16(0xE3C1); break; + case x86_ECX: AddCode16(0xE1C1); break; + case x86_EDX: AddCode16(0xE2C1); break; + case x86_ESI: AddCode16(0xE6C1); break; + case x86_EDI: AddCode16(0xE7C1); break; + case x86_ESP: AddCode16(0xE4C1); break; + case x86_EBP: AddCode16(0xE5C1); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Immediate); + AddCode8(Immediate); } void CX86Ops::ShiftRightSign(x86Reg reg) @@ -2775,14 +2778,14 @@ void CX86Ops::ShiftRightSign(x86Reg reg) CPU_Message(" sar %s, cl", x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xF8D3); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xFBD3); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xF9D3); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xFAD3); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xFED3); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xFFD3); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xFCD3); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xFDD3); break; + case x86_EAX: AddCode16(0xF8D3); break; + case x86_EBX: AddCode16(0xFBD3); break; + case x86_ECX: AddCode16(0xF9D3); break; + case x86_EDX: AddCode16(0xFAD3); break; + case x86_ESI: AddCode16(0xFED3); break; + case x86_EDI: AddCode16(0xFFD3); break; + case x86_ESP: AddCode16(0xFCD3); break; + case x86_EBP: AddCode16(0xFDD3); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2793,18 +2796,18 @@ void CX86Ops::ShiftRightSignImmed(x86Reg reg, uint8_t Immediate) CPU_Message(" sar %s, %Xh", x86_Name(reg), Immediate); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xF8C1); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xFBC1); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xF9C1); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xFAC1); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xFEC1); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xFFC1); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xFCC1); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xFDC1); break; + case x86_EAX: AddCode16(0xF8C1); break; + case x86_EBX: AddCode16(0xFBC1); break; + case x86_ECX: AddCode16(0xF9C1); break; + case x86_EDX: AddCode16(0xFAC1); break; + case x86_ESI: AddCode16(0xFEC1); break; + case x86_EDI: AddCode16(0xFFC1); break; + case x86_ESP: AddCode16(0xFCC1); break; + case x86_EBP: AddCode16(0xFDC1); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Immediate); + AddCode8(Immediate); } void CX86Ops::ShiftRightUnsign(x86Reg reg) @@ -2812,14 +2815,14 @@ void CX86Ops::ShiftRightUnsign(x86Reg reg) CPU_Message(" shr %s, cl", x86_Name(reg)); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE8D3); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xEBD3); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE9D3); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xEAD3); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xEED3); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xEFD3); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xECD3); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xEDD3); break; + case x86_EAX: AddCode16(0xE8D3); break; + case x86_EBX: AddCode16(0xEBD3); break; + case x86_ECX: AddCode16(0xE9D3); break; + case x86_EDX: AddCode16(0xEAD3); break; + case x86_ESI: AddCode16(0xEED3); break; + case x86_EDI: AddCode16(0xEFD3); break; + case x86_ESP: AddCode16(0xECD3); break; + case x86_EBP: AddCode16(0xEDD3); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -2830,7 +2833,7 @@ void CX86Ops::ShiftRightDouble(x86Reg Destination, x86Reg Source) uint8_t s = 0xC0; CPU_Message(" shrd %s, %s, cl", x86_Name(Destination), x86_Name(Source)); - PUTDST16(m_RecompPos, 0xAD0F); + AddCode16(0xAD0F); switch (Destination) { @@ -2860,7 +2863,7 @@ void CX86Ops::ShiftRightDouble(x86Reg Destination, x86Reg Source) g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, s); + AddCode8(s); } void CX86Ops::ShiftRightDoubleImmed(x86Reg Destination, x86Reg Source, uint8_t Immediate) @@ -2868,7 +2871,7 @@ void CX86Ops::ShiftRightDoubleImmed(x86Reg Destination, x86Reg Source, uint8_t I uint8_t s = 0xC0; CPU_Message(" shrd %s, %s, %Xh", x86_Name(Destination), x86_Name(Source), Immediate); - PUTDST16(m_RecompPos, 0xAC0F); + AddCode16(0xAC0F); switch (Destination) { @@ -2898,8 +2901,8 @@ void CX86Ops::ShiftRightDoubleImmed(x86Reg Destination, x86Reg Source, uint8_t I g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, s); - PUTDST8(m_RecompPos, Immediate); + AddCode8(s); + AddCode8(Immediate); } void CX86Ops::ShiftRightUnsignImmed(x86Reg reg, uint8_t Immediate) @@ -2907,18 +2910,18 @@ void CX86Ops::ShiftRightUnsignImmed(x86Reg reg, uint8_t Immediate) CPU_Message(" shr %s, %Xh", x86_Name(reg), Immediate); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE8C1); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xEBC1); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE9C1); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xEAC1); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xEEC1); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xEFC1); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xECC1); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xEDC1); break; + case x86_EAX: AddCode16(0xE8C1); break; + case x86_EBX: AddCode16(0xEBC1); break; + case x86_ECX: AddCode16(0xE9C1); break; + case x86_EDX: AddCode16(0xEAC1); break; + case x86_ESI: AddCode16(0xEEC1); break; + case x86_EDI: AddCode16(0xEFC1); break; + case x86_ESP: AddCode16(0xECC1); break; + case x86_EBP: AddCode16(0xEDC1); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Immediate); + AddCode8(Immediate); } void CX86Ops::SbbConstFromX86Reg(x86Reg reg, uint32_t Const) @@ -2928,35 +2931,35 @@ void CX86Ops::SbbConstFromX86Reg(x86Reg reg, uint32_t Const) { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xD881); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xDB81); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xD981); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xDA81); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xDE81); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xDF81); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xDC81); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xDD81); break; + case x86_EAX: AddCode16(0xD881); break; + case x86_EBX: AddCode16(0xDB81); break; + case x86_ECX: AddCode16(0xD981); break; + case x86_EDX: AddCode16(0xDA81); break; + case x86_ESI: AddCode16(0xDE81); break; + case x86_EDI: AddCode16(0xDF81); break; + case x86_ESP: AddCode16(0xDC81); break; + case x86_EBP: AddCode16(0xDD81); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Const); + AddCode32(Const); } else { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xD883); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xDB83); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xD983); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xDA83); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xDE83); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xDF83); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xDC83); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xDD83); break; + case x86_EAX: AddCode16(0xD883); break; + case x86_EBX: AddCode16(0xDB83); break; + case x86_ECX: AddCode16(0xD983); break; + case x86_EDX: AddCode16(0xDA83); break; + case x86_ESI: AddCode16(0xDE83); break; + case x86_EDI: AddCode16(0xDF83); break; + case x86_ESP: AddCode16(0xDC83); break; + case x86_EBP: AddCode16(0xDD83); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Const); + AddCode8((uint8_t)Const); } } @@ -2965,18 +2968,18 @@ void CX86Ops::SbbVariableFromX86reg(x86Reg reg, void * Variable, const char * Va CPU_Message(" sbb %s, dword ptr [%s]", x86_Name(reg), VariableName); switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x051B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D1B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D1B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x151B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x351B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D1B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x251B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D1B); break; + case x86_EAX: AddCode16(0x051B); break; + case x86_EBX: AddCode16(0x1D1B); break; + case x86_ECX: AddCode16(0x0D1B); break; + case x86_EDX: AddCode16(0x151B); break; + case x86_ESI: AddCode16(0x351B); break; + case x86_EDI: AddCode16(0x3D1B); break; + case x86_ESP: AddCode16(0x251B); break; + case x86_EBP: AddCode16(0x2D1B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::SbbX86RegToX86Reg(x86Reg Destination, x86Reg Source) @@ -3009,16 +3012,16 @@ void CX86Ops::SbbX86RegToX86Reg(x86Reg Destination, x86Reg Source) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::SubConstFromVariable(uint32_t Const, void *Variable, const char * VariableName) { CPU_Message(" sub dword ptr [%s], 0x%X", VariableName, Const); - PUTDST16(m_RecompPos, 0x2D81); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x2D81); + AddCode32((uint32_t)Variable); + AddCode32(Const); } void CX86Ops::SubConstFromX86Reg(x86Reg reg, uint32_t Const) @@ -3028,35 +3031,35 @@ void CX86Ops::SubConstFromX86Reg(x86Reg reg, uint32_t Const) { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE881); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xEB81); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE981); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xEA81); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xEE81); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xEF81); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xEC81); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xED81); break; + case x86_EAX: AddCode16(0xE881); break; + case x86_EBX: AddCode16(0xEB81); break; + case x86_ECX: AddCode16(0xE981); break; + case x86_EDX: AddCode16(0xEA81); break; + case x86_ESI: AddCode16(0xEE81); break; + case x86_EDI: AddCode16(0xEF81); break; + case x86_ESP: AddCode16(0xEC81); break; + case x86_EBP: AddCode16(0xED81); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Const); + AddCode32(Const); } else { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xE883); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xEB83); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xE983); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xEA83); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xEE83); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xEF83); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xEC83); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xED83); break; + case x86_EAX: AddCode16(0xE883); break; + case x86_EBX: AddCode16(0xEB83); break; + case x86_ECX: AddCode16(0xE983); break; + case x86_EDX: AddCode16(0xEA83); break; + case x86_ESI: AddCode16(0xEE83); break; + case x86_EDI: AddCode16(0xEF83); break; + case x86_ESP: AddCode16(0xEC83); break; + case x86_EBP: AddCode16(0xED83); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Const); + AddCode8((uint8_t)Const); } } @@ -3066,18 +3069,18 @@ void CX86Ops::SubVariableFromX86reg(x86Reg reg, void * Variable, const char * Va switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x052B); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D2B); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D2B); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x152B); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x352B); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D2B); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x252B); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D2B); break; + case x86_EAX: AddCode16(0x052B); break; + case x86_EBX: AddCode16(0x1D2B); break; + case x86_ECX: AddCode16(0x0D2B); break; + case x86_EDX: AddCode16(0x152B); break; + case x86_ESI: AddCode16(0x352B); break; + case x86_EDI: AddCode16(0x3D2B); break; + case x86_ESP: AddCode16(0x252B); break; + case x86_EBP: AddCode16(0x2D2B); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::SubX86RegToX86Reg(x86Reg Destination, x86Reg Source) @@ -3112,7 +3115,7 @@ void CX86Ops::SubX86RegToX86Reg(x86Reg Destination, x86Reg Source) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::TestConstToX86Reg(uint32_t Const, x86Reg reg) @@ -3121,26 +3124,26 @@ void CX86Ops::TestConstToX86Reg(uint32_t Const, x86Reg reg) switch (reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0xA9); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xC3F7); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xC1F7); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xC2F7); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xC6F7); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xC7F7); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xC4F7); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xC5F7); break; + case x86_EAX: AddCode8(0xA9); break; + case x86_EBX: AddCode16(0xC3F7); break; + case x86_ECX: AddCode16(0xC1F7); break; + case x86_EDX: AddCode16(0xC2F7); break; + case x86_ESI: AddCode16(0xC6F7); break; + case x86_EDI: AddCode16(0xC7F7); break; + case x86_ESP: AddCode16(0xC4F7); break; + case x86_EBP: AddCode16(0xC5F7); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Const); + AddCode32(Const); } void CX86Ops::TestVariable(uint32_t Const, void * Variable, const char * VariableName) { CPU_Message(" test dword ptr ds:[%s], 0x%X", VariableName, Const); - PUTDST16(m_RecompPos, 0x05F7); - PUTDST32(m_RecompPos, Variable); - PUTDST32(m_RecompPos, Const); + AddCode16(0x05F7); + AddCode32((uint32_t)Variable); + AddCode32(Const); } void CX86Ops::TestX86RegToX86Reg(x86Reg Destination, x86Reg Source) @@ -3173,7 +3176,7 @@ void CX86Ops::TestX86RegToX86Reg(x86Reg Destination, x86Reg Source) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::XorConstToX86Reg(x86Reg reg, uint32_t Const) @@ -3183,35 +3186,35 @@ void CX86Ops::XorConstToX86Reg(x86Reg reg, uint32_t Const) { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xF081); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xF381); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xF181); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xF281); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xF681); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xF781); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xF481); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xF581); break; + case x86_EAX: AddCode16(0xF081); break; + case x86_EBX: AddCode16(0xF381); break; + case x86_ECX: AddCode16(0xF181); break; + case x86_EDX: AddCode16(0xF281); break; + case x86_ESI: AddCode16(0xF681); break; + case x86_EDI: AddCode16(0xF781); break; + case x86_ESP: AddCode16(0xF481); break; + case x86_EBP: AddCode16(0xF581); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Const); + AddCode32(Const); } else { switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0xF083); break; - case x86_EBX: PUTDST16(m_RecompPos, 0xF383); break; - case x86_ECX: PUTDST16(m_RecompPos, 0xF183); break; - case x86_EDX: PUTDST16(m_RecompPos, 0xF283); break; - case x86_ESI: PUTDST16(m_RecompPos, 0xF683); break; - case x86_EDI: PUTDST16(m_RecompPos, 0xF783); break; - case x86_ESP: PUTDST16(m_RecompPos, 0xF483); break; - case x86_EBP: PUTDST16(m_RecompPos, 0xF583); break; + case x86_EAX: AddCode16(0xF083); break; + case x86_EBX: AddCode16(0xF383); break; + case x86_ECX: AddCode16(0xF183); break; + case x86_EDX: AddCode16(0xF283); break; + case x86_ESI: AddCode16(0xF683); break; + case x86_EDI: AddCode16(0xF783); break; + case x86_ESP: AddCode16(0xF483); break; + case x86_EBP: AddCode16(0xF583); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, Const); + AddCode8((uint8_t)Const); } } @@ -3247,7 +3250,7 @@ void CX86Ops::XorX86RegToX86Reg(x86Reg Source, x86Reg Destination) default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::XorVariableToX86reg(void *Variable, const char * VariableName, x86Reg reg) @@ -3256,31 +3259,31 @@ void CX86Ops::XorVariableToX86reg(void *Variable, const char * VariableName, x86 switch (reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x0533); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x1D33); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x0D33); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x1533); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x3533); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x3D33); break; - case x86_ESP: PUTDST16(m_RecompPos, 0x2533); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x2D33); break; + case x86_EAX: AddCode16(0x0533); break; + case x86_EBX: AddCode16(0x1D33); break; + case x86_ECX: AddCode16(0x0D33); break; + case x86_EDX: AddCode16(0x1533); break; + case x86_ESI: AddCode16(0x3533); break; + case x86_EDI: AddCode16(0x3D33); break; + case x86_ESP: AddCode16(0x2533); break; + case x86_EBP: AddCode16(0x2D33); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, Variable); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuAbs(void) { CPU_Message(" fabs ST(0)"); - PUTDST16(m_RecompPos, 0xE1D9); + AddCode16(0xE1D9); } void CX86Ops::fpuAddDword(void *Variable, const char * VariableName) { CPU_Message(" fadd ST(0), dword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x05D8); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x05D8); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuAddDwordRegPointer(x86Reg x86Pointer) @@ -3288,12 +3291,12 @@ void CX86Ops::fpuAddDwordRegPointer(x86Reg x86Pointer) CPU_Message(" fadd ST(0), dword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x00D8); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x03D8); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x01D8); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x02D8); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x06D8); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x07D8); break; + case x86_EAX: AddCode16(0x00D8); break; + case x86_EBX: AddCode16(0x03D8); break; + case x86_ECX: AddCode16(0x01D8); break; + case x86_EDX: AddCode16(0x02D8); break; + case x86_ESI: AddCode16(0x06D8); break; + case x86_EDI: AddCode16(0x07D8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3303,8 +3306,8 @@ void CX86Ops::fpuAddDwordRegPointer(x86Reg x86Pointer) void CX86Ops::fpuAddQword(void *Variable, const char * VariableName) { CPU_Message(" fadd ST(0), qword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x05DC); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x05DC); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuAddQwordRegPointer(x86Reg x86Pointer) @@ -3312,12 +3315,12 @@ void CX86Ops::fpuAddQwordRegPointer(x86Reg x86Pointer) CPU_Message(" fadd ST(0), qword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x00DC); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x03DC); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x01DC); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x02DC); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x06DC); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x07DC); break; + case x86_EAX: AddCode16(0x00DC); break; + case x86_EBX: AddCode16(0x03DC); break; + case x86_ECX: AddCode16(0x01DC); break; + case x86_EDX: AddCode16(0x02DC); break; + case x86_ESI: AddCode16(0x06DC); break; + case x86_EDI: AddCode16(0x07DC); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3328,14 +3331,14 @@ void CX86Ops::fpuAddReg(x86FpuValues x86reg) { CPU_Message(" fadd ST(0), %s", fpu_Name(x86reg)); switch (x86reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC0D8); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC1D8); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xC2D8); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xC3D8); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xC4D8); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xC5D8); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xC6D8); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xC7D8); break; + case x86_ST0: AddCode16(0xC0D8); break; + case x86_ST1: AddCode16(0xC1D8); break; + case x86_ST2: AddCode16(0xC2D8); break; + case x86_ST3: AddCode16(0xC3D8); break; + case x86_ST4: AddCode16(0xC4D8); break; + case x86_ST5: AddCode16(0xC5D8); break; + case x86_ST6: AddCode16(0xC6D8); break; + case x86_ST7: AddCode16(0xC7D8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3348,14 +3351,14 @@ void CX86Ops::fpuAddRegPop(int * StackPos, x86FpuValues reg) *StackPos = (*StackPos + 1) & 7; switch (reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC0DE); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC1DE); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xC2DE); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xC3DE); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xC4DE); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xC5DE); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xC6DE); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xC7DE); break; + case x86_ST0: AddCode16(0xC0DE); break; + case x86_ST1: AddCode16(0xC1DE); break; + case x86_ST2: AddCode16(0xC2DE); break; + case x86_ST3: AddCode16(0xC3DE); break; + case x86_ST4: AddCode16(0xC4DE); break; + case x86_ST5: AddCode16(0xC5DE); break; + case x86_ST6: AddCode16(0xC6DE); break; + case x86_ST7: AddCode16(0xC7DE); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3365,8 +3368,8 @@ void CX86Ops::fpuAddRegPop(int * StackPos, x86FpuValues reg) void CX86Ops::fpuComDword(void *Variable, const char * VariableName, bool Pop) { CPU_Message(" fcom%s ST(0), dword ptr [%s]", m_fpupop[Pop], VariableName); - PUTDST16(m_RecompPos, Pop ? 0x1DD8 : 0x15D8); - PUTDST32(m_RecompPos, Variable); + AddCode16(Pop ? 0x1DD8 : 0x15D8); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuComDwordRegPointer(x86Reg x86Pointer, bool Pop) @@ -3391,14 +3394,14 @@ void CX86Ops::fpuComDwordRegPointer(x86Reg x86Pointer, bool Pop) x86Command |= 0x0800; } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::fpuComQword(void *Variable, const char * VariableName, bool Pop) { CPU_Message(" fcom%s ST(0), qword ptr [%s]", m_fpupop[Pop], VariableName); - PUTDST16(m_RecompPos, Pop ? 0x1DDC : 0x15DC); - PUTDST32(m_RecompPos, Variable); + AddCode16(Pop ? 0x1DDC : 0x15DC); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuComQwordRegPointer(x86Reg x86Pointer, bool Pop) @@ -3423,7 +3426,7 @@ void CX86Ops::fpuComQwordRegPointer(x86Reg x86Pointer, bool Pop) x86Command |= 0x0800; } - PUTDST16(m_RecompPos, x86Command); + AddCode16(x86Command); } void CX86Ops::fpuComReg(x86FpuValues x86reg, bool Pop) @@ -3433,14 +3436,14 @@ void CX86Ops::fpuComReg(x86FpuValues x86reg, bool Pop) switch (x86reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xD0D8 | s); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xD1D8 | s); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xD2D8 | s); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xD3D8 | s); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xD4D8 | s); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xD5D8 | s); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xD6D8 | s); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xD7D8 | s); break; + case x86_ST0: AddCode16((uint16_t)(0xD0D8 | s)); break; + case x86_ST1: AddCode16((uint16_t)(0xD1D8 | s)); break; + case x86_ST2: AddCode16((uint16_t)(0xD2D8 | s)); break; + case x86_ST3: AddCode16((uint16_t)(0xD3D8 | s)); break; + case x86_ST4: AddCode16((uint16_t)(0xD4D8 | s)); break; + case x86_ST5: AddCode16((uint16_t)(0xD5D8 | s)); break; + case x86_ST6: AddCode16((uint16_t)(0xD6D8 | s)); break; + case x86_ST7: AddCode16((uint16_t)(0xD7D8 | s)); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3450,8 +3453,8 @@ void CX86Ops::fpuComReg(x86FpuValues x86reg, bool Pop) void CX86Ops::fpuDivDword(void *Variable, const char * VariableName) { CPU_Message(" fdiv ST(0), dword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x35D8); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x35D8); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuDivDwordRegPointer(x86Reg x86Pointer) @@ -3459,12 +3462,12 @@ void CX86Ops::fpuDivDwordRegPointer(x86Reg x86Pointer) CPU_Message(" fdiv ST(0), dword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x30D8); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x33D8); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x31D8); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x32D8); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x36D8); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x37D8); break; + case x86_EAX: AddCode16(0x30D8); break; + case x86_EBX: AddCode16(0x33D8); break; + case x86_ECX: AddCode16(0x31D8); break; + case x86_EDX: AddCode16(0x32D8); break; + case x86_ESI: AddCode16(0x36D8); break; + case x86_EDI: AddCode16(0x37D8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3474,8 +3477,8 @@ void CX86Ops::fpuDivDwordRegPointer(x86Reg x86Pointer) void CX86Ops::fpuDivQword(void *Variable, const char * VariableName) { CPU_Message(" fdiv ST(0), qword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x35DC); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x35DC); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuDivQwordRegPointer(x86Reg x86Pointer) @@ -3483,12 +3486,12 @@ void CX86Ops::fpuDivQwordRegPointer(x86Reg x86Pointer) CPU_Message(" fdiv ST(0), qword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x30DC); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x33DC); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x31DC); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x32DC); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x36DC); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x37DC); break; + case x86_EAX: AddCode16(0x30DC); break; + case x86_EBX: AddCode16(0x33DC); break; + case x86_ECX: AddCode16(0x31DC); break; + case x86_EDX: AddCode16(0x32DC); break; + case x86_ESI: AddCode16(0x36DC); break; + case x86_EDI: AddCode16(0x37DC); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3500,14 +3503,14 @@ void CX86Ops::fpuDivReg(x86FpuValues Reg) CPU_Message(" fdiv ST(0), %s", fpu_Name(Reg)); switch (Reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xF0D8); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xF1D8); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xF2D8); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xF3D8); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xF4D8); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xF5D8); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xF6D8); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xF7D8); break; + case x86_ST0: AddCode16(0xF0D8); break; + case x86_ST1: AddCode16(0xF1D8); break; + case x86_ST2: AddCode16(0xF2D8); break; + case x86_ST3: AddCode16(0xF3D8); break; + case x86_ST4: AddCode16(0xF4D8); break; + case x86_ST5: AddCode16(0xF5D8); break; + case x86_ST6: AddCode16(0xF6D8); break; + case x86_ST7: AddCode16(0xF7D8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3519,14 +3522,14 @@ void CX86Ops::fpuDivRegPop(x86FpuValues reg) CPU_Message(" fdivp ST(0), %s", fpu_Name(reg)); switch (reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xF8DE); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xF9DE); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xFADE); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xFBDE); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xFCDE); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xFDDE); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xFEDE); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xFFDE); break; + case x86_ST0: AddCode16(0xF8DE); break; + case x86_ST1: AddCode16(0xF9DE); break; + case x86_ST2: AddCode16(0xFADE); break; + case x86_ST3: AddCode16(0xFBDE); break; + case x86_ST4: AddCode16(0xFCDE); break; + case x86_ST5: AddCode16(0xFDDE); break; + case x86_ST6: AddCode16(0xFEDE); break; + case x86_ST7: AddCode16(0xFFDE); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3538,14 +3541,14 @@ void CX86Ops::fpuExchange(x86FpuValues Reg) CPU_Message(" fxch ST(0), %s", fpu_Name(Reg)); switch (Reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC8D9); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC9D9); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xCAD9); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xCBD9); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xCCD9); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xCDD9); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xCED9); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xCFD9); break; + case x86_ST0: AddCode16(0xC8D9); break; + case x86_ST1: AddCode16(0xC9D9); break; + case x86_ST2: AddCode16(0xCAD9); break; + case x86_ST3: AddCode16(0xCBD9); break; + case x86_ST4: AddCode16(0xCCD9); break; + case x86_ST5: AddCode16(0xCDD9); break; + case x86_ST6: AddCode16(0xCED9); break; + case x86_ST7: AddCode16(0xCFD9); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3557,14 +3560,14 @@ void CX86Ops::fpuFree(x86FpuValues Reg) CPU_Message(" ffree %s", fpu_Name(Reg)); switch (Reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC0DD); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC1DD); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xC2DD); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xC3DD); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xC4DD); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xC5DD); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xC6DD); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xC7DD); break; + case x86_ST0: AddCode16(0xC0DD); break; + case x86_ST1: AddCode16(0xC1DD); break; + case x86_ST2: AddCode16(0xC2DD); break; + case x86_ST3: AddCode16(0xC3DD); break; + case x86_ST4: AddCode16(0xC4DD); break; + case x86_ST5: AddCode16(0xC5DD); break; + case x86_ST6: AddCode16(0xC6DD); break; + case x86_ST7: AddCode16(0xC7DD); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3575,44 +3578,44 @@ void CX86Ops::fpuDecStack(int * StackPos) { CPU_Message(" fdecstp"); *StackPos = (*StackPos - 1) & 7; - PUTDST16(m_RecompPos, 0xF6D9); + AddCode16(0xF6D9); } void CX86Ops::fpuIncStack(int * StackPos) { CPU_Message(" fincstp"); *StackPos = (*StackPos + 1) & 7; - PUTDST16(m_RecompPos, 0xF7D9); + AddCode16(0xF7D9); } void CX86Ops::fpuLoadControl(void *Variable, const char * VariableName) { CPU_Message(" fldcw [%s]", VariableName); - PUTDST16(m_RecompPos, 0x2DD9); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x2DD9); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuLoadDword(int * StackPos, void *Variable, const char * VariableName) { CPU_Message(" fld dword ptr [%s]", VariableName); *StackPos = (*StackPos - 1) & 7; - PUTDST16(m_RecompPos, 0x05D9); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x05D9); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuLoadDwordFromX86Reg(int * StackPos, x86Reg x86reg) { CPU_Message(" fld dword ptr [%s]", x86_Name(x86reg)); *StackPos = (*StackPos - 1) & 7; - PUTDST8(m_RecompPos, 0xD9); + AddCode8(0xD9); switch (x86reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x00); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x03); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x01); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x02); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x06); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x07); break; + case x86_EAX: AddCode8(0x00); break; + case x86_EBX: AddCode8(0x03); break; + case x86_ECX: AddCode8(0x01); break; + case x86_EDX: AddCode8(0x02); break; + case x86_ESI: AddCode8(0x06); break; + case x86_EDI: AddCode8(0x07); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -3624,17 +3627,17 @@ void CX86Ops::fpuLoadDwordFromN64Mem(int * StackPos, x86Reg x86reg) *StackPos = (*StackPos - 1) & 7; switch (x86reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80D9); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83D9); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81D9); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82D9); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86D9); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87D9); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85D9); break; + case x86_EAX: AddCode16(0x80D9); break; + case x86_EBX: AddCode16(0x83D9); break; + case x86_ECX: AddCode16(0x81D9); break; + case x86_EDX: AddCode16(0x82D9); break; + case x86_ESI: AddCode16(0x86D9); break; + case x86_EDI: AddCode16(0x87D9); break; + case x86_EBP: AddCode16(0x85D9); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::fpuLoadInt32bFromN64Mem(int * StackPos, x86Reg x86reg) @@ -3643,40 +3646,40 @@ void CX86Ops::fpuLoadInt32bFromN64Mem(int * StackPos, x86Reg x86reg) *StackPos = (*StackPos - 1) & 7; switch (x86reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80DB); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83DB); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81DB); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82DB); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86DB); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87DB); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85DB); break; + case x86_EAX: AddCode16(0x80DB); break; + case x86_EBX: AddCode16(0x83DB); break; + case x86_ECX: AddCode16(0x81DB); break; + case x86_EDX: AddCode16(0x82DB); break; + case x86_ESI: AddCode16(0x86DB); break; + case x86_EDI: AddCode16(0x87DB); break; + case x86_EBP: AddCode16(0x85DB); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::fpuLoadIntegerDword(int * StackPos, void *Variable, const char * VariableName) { CPU_Message(" fild dword ptr [%s]", VariableName); *StackPos = (*StackPos - 1) & 7; - PUTDST16(m_RecompPos, 0x05DB); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x05DB); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuLoadIntegerDwordFromX86Reg(int * StackPos, x86Reg x86reg) { CPU_Message(" fild dword ptr [%s]", x86_Name(x86reg)); *StackPos = (*StackPos - 1) & 7; - PUTDST8(m_RecompPos, 0xDB); + AddCode8(0xDB); switch (x86reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x00); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x03); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x01); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x02); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x06); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x07); break; + case x86_EAX: AddCode8(0x00); break; + case x86_EBX: AddCode8(0x03); break; + case x86_ECX: AddCode8(0x01); break; + case x86_EDX: AddCode8(0x02); break; + case x86_ESI: AddCode8(0x06); break; + case x86_EDI: AddCode8(0x07); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -3686,23 +3689,23 @@ void CX86Ops::fpuLoadIntegerQword(int * StackPos, void *Variable, const char * V { CPU_Message(" fild qword ptr [%s]", VariableName); *StackPos = (*StackPos - 1) & 7; - PUTDST16(m_RecompPos, 0x2DDF); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x2DDF); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuLoadIntegerQwordFromX86Reg(int * StackPos, x86Reg x86reg) { CPU_Message(" fild qword ptr [%s]", x86_Name(x86reg)); *StackPos = (*StackPos - 1) & 7; - PUTDST8(m_RecompPos, 0xDF); + AddCode8(0xDF); switch (x86reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x28); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x2B); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x29); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x2A); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x2E); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x2F); break; + case x86_EAX: AddCode8(0x28); break; + case x86_EBX: AddCode8(0x2B); break; + case x86_ECX: AddCode8(0x29); break; + case x86_EDX: AddCode8(0x2A); break; + case x86_ESI: AddCode8(0x2E); break; + case x86_EDI: AddCode8(0x2F); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -3712,23 +3715,23 @@ void CX86Ops::fpuLoadQword(int * StackPos, void *Variable, const char * Variable { CPU_Message(" fld qword ptr [%s]", VariableName); *StackPos = (*StackPos - 1) & 7; - PUTDST16(m_RecompPos, 0x05DD); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x05DD); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuLoadQwordFromX86Reg(int * StackPos, x86Reg x86reg) { CPU_Message(" fld qword ptr [%s]", x86_Name(x86reg)); *StackPos = (*StackPos - 1) & 7; - PUTDST8(m_RecompPos, 0xDD); + AddCode8(0xDD); switch (x86reg) { - case x86_EAX: PUTDST8(m_RecompPos, 0x00); break; - case x86_EBX: PUTDST8(m_RecompPos, 0x03); break; - case x86_ECX: PUTDST8(m_RecompPos, 0x01); break; - case x86_EDX: PUTDST8(m_RecompPos, 0x02); break; - case x86_ESI: PUTDST8(m_RecompPos, 0x06); break; - case x86_EDI: PUTDST8(m_RecompPos, 0x07); break; + case x86_EAX: AddCode8(0x00); break; + case x86_EBX: AddCode8(0x03); break; + case x86_ECX: AddCode8(0x01); break; + case x86_EDX: AddCode8(0x02); break; + case x86_ESI: AddCode8(0x06); break; + case x86_EDI: AddCode8(0x07); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } @@ -3740,17 +3743,17 @@ void CX86Ops::fpuLoadQwordFromN64Mem(int * StackPos, x86Reg x86reg) *StackPos = (*StackPos - 1) & 7; switch (x86reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x80DD); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x83DD); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x81DD); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x82DD); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x86DD); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x87DD); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x85DD); break; + case x86_EAX: AddCode16(0x80DD); break; + case x86_EBX: AddCode16(0x83DD); break; + case x86_ECX: AddCode16(0x81DD); break; + case x86_EDX: AddCode16(0x82DD); break; + case x86_ESI: AddCode16(0x86DD); break; + case x86_EDI: AddCode16(0x87DD); break; + case x86_EBP: AddCode16(0x85DD); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::fpuLoadReg(int * StackPos, x86FpuValues Reg) @@ -3759,14 +3762,14 @@ void CX86Ops::fpuLoadReg(int * StackPos, x86FpuValues Reg) *StackPos = (*StackPos - 1) & 7; switch (Reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC0D9); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC1D9); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xC2D9); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xC3D9); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xC4D9); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xC5D9); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xC6D9); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xC7D9); break; + case x86_ST0: AddCode16(0xC0D9); break; + case x86_ST1: AddCode16(0xC1D9); break; + case x86_ST2: AddCode16(0xC2D9); break; + case x86_ST3: AddCode16(0xC3D9); break; + case x86_ST4: AddCode16(0xC4D9); break; + case x86_ST5: AddCode16(0xC5D9); break; + case x86_ST6: AddCode16(0xC6D9); break; + case x86_ST7: AddCode16(0xC7D9); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3776,8 +3779,8 @@ void CX86Ops::fpuLoadReg(int * StackPos, x86FpuValues Reg) void CX86Ops::fpuMulDword(void *Variable, const char * VariableName) { CPU_Message(" fmul ST(0), dword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x0DD8); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x0DD8); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuMulDwordRegPointer(x86Reg x86Pointer) @@ -3785,12 +3788,12 @@ void CX86Ops::fpuMulDwordRegPointer(x86Reg x86Pointer) CPU_Message(" fmul ST(0), dword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x08D8); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x0BD8); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x09D8); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x0AD8); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x0ED8); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x0FD8); break; + case x86_EAX: AddCode16(0x08D8); break; + case x86_EBX: AddCode16(0x0BD8); break; + case x86_ECX: AddCode16(0x09D8); break; + case x86_EDX: AddCode16(0x0AD8); break; + case x86_ESI: AddCode16(0x0ED8); break; + case x86_EDI: AddCode16(0x0FD8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3800,8 +3803,8 @@ void CX86Ops::fpuMulDwordRegPointer(x86Reg x86Pointer) void CX86Ops::fpuMulQword(void *Variable, const char * VariableName) { CPU_Message(" fmul ST(0), qword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x0DDC); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x0DDC); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuMulQwordRegPointer(x86Reg x86Pointer) @@ -3809,12 +3812,12 @@ void CX86Ops::fpuMulQwordRegPointer(x86Reg x86Pointer) CPU_Message(" fmul ST(0), qword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x08DC); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x0BDC); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x09DC); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x0ADC); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x0EDC); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x0FDC); break; + case x86_EAX: AddCode16(0x08DC); break; + case x86_EBX: AddCode16(0x0BDC); break; + case x86_ECX: AddCode16(0x09DC); break; + case x86_EDX: AddCode16(0x0ADC); break; + case x86_ESI: AddCode16(0x0EDC); break; + case x86_EDI: AddCode16(0x0FDC); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3826,14 +3829,14 @@ void CX86Ops::fpuMulReg(x86FpuValues x86reg) CPU_Message(" fmul ST(0), %s", fpu_Name(x86reg)); switch (x86reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC8D8); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC9D8); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xCAD8); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xCBD8); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xCCD8); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xCDD8); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xCED8); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xCFD8); break; + case x86_ST0: AddCode16(0xC8D8); break; + case x86_ST1: AddCode16(0xC9D8); break; + case x86_ST2: AddCode16(0xCAD8); break; + case x86_ST3: AddCode16(0xCBD8); break; + case x86_ST4: AddCode16(0xCCD8); break; + case x86_ST5: AddCode16(0xCDD8); break; + case x86_ST6: AddCode16(0xCED8); break; + case x86_ST7: AddCode16(0xCFD8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3845,14 +3848,14 @@ void CX86Ops::fpuMulRegPop(x86FpuValues x86reg) CPU_Message(" fmulp ST(0), %s", fpu_Name(x86reg)); switch (x86reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xC8DE); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xC9DE); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xCADE); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xCBDE); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xCCDE); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xCDDE); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xCEDE); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xCFDE); break; + case x86_ST0: AddCode16(0xC8DE); break; + case x86_ST1: AddCode16(0xC9DE); break; + case x86_ST2: AddCode16(0xCADE); break; + case x86_ST3: AddCode16(0xCBDE); break; + case x86_ST4: AddCode16(0xCCDE); break; + case x86_ST5: AddCode16(0xCDDE); break; + case x86_ST6: AddCode16(0xCEDE); break; + case x86_ST7: AddCode16(0xCFDE); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -3862,26 +3865,26 @@ void CX86Ops::fpuMulRegPop(x86FpuValues x86reg) void CX86Ops::fpuNeg(void) { CPU_Message(" fchs ST(0)"); - PUTDST16(m_RecompPos, 0xE0D9); + AddCode16(0xE0D9); } void CX86Ops::fpuRound(void) { CPU_Message(" frndint ST(0)"); - PUTDST16(m_RecompPos, 0xFCD9); + AddCode16(0xFCD9); } void CX86Ops::fpuSqrt(void) { CPU_Message(" fsqrt ST(0)"); - PUTDST16(m_RecompPos, 0xFAD9); + AddCode16(0xFAD9); } void CX86Ops::fpuStoreControl(void *Variable, const char * VariableName) { CPU_Message(" fnstcw [%s]", VariableName); - PUTDST16(m_RecompPos, 0x3DD9); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x3DD9); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuStoreDword(int * StackPos, void *Variable, const char * VariableName, bool pop) @@ -3893,8 +3896,8 @@ void CX86Ops::fpuStoreDword(int * StackPos, void *Variable, const char * Variabl *StackPos = (*StackPos + 1) & 7; } - PUTDST16(m_RecompPos, pop ? 0x1DD9 : 0x15D9); - PUTDST32(m_RecompPos, Variable); + AddCode16(pop ? 0x1DD9 : 0x15D9); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuStoreDwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) @@ -3908,7 +3911,7 @@ void CX86Ops::fpuStoreDwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) *StackPos = (*StackPos + 1) & 7; } - PUTDST8(m_RecompPos, 0xD9); + AddCode8(0xD9); switch (x86reg) { @@ -3922,7 +3925,7 @@ void CX86Ops::fpuStoreDwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, pop ? (Command + 0x8) : Command); + AddCode8(pop ? (Command + 0x8) : Command); } void CX86Ops::fpuStoreDwordToN64Mem(int * StackPos, x86Reg x86reg, bool Pop) @@ -3938,18 +3941,18 @@ void CX86Ops::fpuStoreDwordToN64Mem(int * StackPos, x86Reg x86reg, bool Pop) switch (x86reg) { - case x86_EAX: PUTDST16(m_RecompPos, 0x90D9 | s); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x93D9 | s); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x91D9 | s); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x92D9 | s); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x96D9 | s); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x97D9 | s); break; - case x86_EBP: PUTDST16(m_RecompPos, 0x95D9 | s); break; + case x86_EAX: AddCode16((uint16_t)(0x90D9 | s)); break; + case x86_EBX: AddCode16((uint16_t)(0x93D9 | s)); break; + case x86_ECX: AddCode16((uint16_t)(0x91D9 | s)); break; + case x86_EDX: AddCode16((uint16_t)(0x92D9 | s)); break; + case x86_ESI: AddCode16((uint16_t)(0x96D9 | s)); break; + case x86_EDI: AddCode16((uint16_t)(0x97D9 | s)); break; + case x86_EBP: AddCode16((uint16_t)(0x95D9 | s)); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST32(m_RecompPos, g_MMU->Rdram()); + AddCode32((uint32_t)g_MMU->Rdram()); } void CX86Ops::fpuStoreIntegerDword(int * StackPos, void *Variable, const char * VariableName, bool pop) @@ -3960,8 +3963,8 @@ void CX86Ops::fpuStoreIntegerDword(int * StackPos, void *Variable, const char * { *StackPos = (*StackPos + 1) & 7; } - PUTDST16(m_RecompPos, pop ? 0x1DDB : 0x15DB); - PUTDST32(m_RecompPos, Variable); + AddCode16(pop ? 0x1DDB : 0x15DB); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuStoreIntegerDwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) @@ -3975,7 +3978,7 @@ void CX86Ops::fpuStoreIntegerDwordFromX86Reg(int * StackPos, x86Reg x86reg, bool *StackPos = (*StackPos + 1) & 7; } - PUTDST8(m_RecompPos, 0xDB); + AddCode8(0xDB); switch (x86reg) { @@ -3989,7 +3992,7 @@ void CX86Ops::fpuStoreIntegerDwordFromX86Reg(int * StackPos, x86Reg x86reg, bool g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, pop ? (Command + 0x8) : Command); + AddCode8(pop ? (Command + 0x8) : Command); } void CX86Ops::fpuStoreIntegerQword(int * StackPos, void *Variable, const char * VariableName, bool pop) @@ -4001,8 +4004,8 @@ void CX86Ops::fpuStoreIntegerQword(int * StackPos, void *Variable, const char * *StackPos = (*StackPos + 1) & 7; } - PUTDST16(m_RecompPos, pop ? 0x3DDF : 0x35DF); - PUTDST32(m_RecompPos, Variable); + AddCode16(pop ? 0x3DDF : 0x35DF); + AddCode32((uint32_t)Variable); if (!pop) { @@ -4021,7 +4024,7 @@ void CX86Ops::fpuStoreIntegerQwordFromX86Reg(int * StackPos, x86Reg x86reg, bool *StackPos = (*StackPos + 1) & 7; } - PUTDST8(m_RecompPos, 0xDF); + AddCode8(0xDF); switch (x86reg) { case x86_EAX: Command = 0x30; break; @@ -4034,7 +4037,7 @@ void CX86Ops::fpuStoreIntegerQwordFromX86Reg(int * StackPos, x86Reg x86reg, bool g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, pop ? (Command + 0x8) : Command); + AddCode8(pop ? (Command + 0x8) : Command); } void CX86Ops::fpuStoreQwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) @@ -4048,7 +4051,7 @@ void CX86Ops::fpuStoreQwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) *StackPos = (*StackPos + 1) & 7; } - PUTDST8(m_RecompPos, 0xDD); + AddCode8(0xDD); switch (x86reg) { @@ -4062,20 +4065,20 @@ void CX86Ops::fpuStoreQwordFromX86Reg(int * StackPos, x86Reg x86reg, bool pop) g_Notify->BreakPoint(__FILE__, __LINE__); } - PUTDST8(m_RecompPos, pop ? (Command + 0x8) : Command); + AddCode8(pop ? (Command + 0x8) : Command); } void CX86Ops::fpuStoreStatus(void) { CPU_Message(" fnstsw ax"); - PUTDST16(m_RecompPos, 0xE0DF); + AddCode16(0xE0DF); } void CX86Ops::fpuSubDword(void *Variable, const char * VariableName) { CPU_Message(" fsub ST(0), dword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x25D8); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x25D8); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuSubDwordRegPointer(x86Reg x86Pointer) @@ -4083,12 +4086,12 @@ void CX86Ops::fpuSubDwordRegPointer(x86Reg x86Pointer) CPU_Message(" fsub ST(0), dword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x20D8); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x23D8); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x21D8); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x22D8); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x26D8); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x27D8); break; + case x86_EAX: AddCode16(0x20D8); break; + case x86_EBX: AddCode16(0x23D8); break; + case x86_ECX: AddCode16(0x21D8); break; + case x86_EDX: AddCode16(0x22D8); break; + case x86_ESI: AddCode16(0x26D8); break; + case x86_EDI: AddCode16(0x27D8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -4098,27 +4101,27 @@ void CX86Ops::fpuSubDwordRegPointer(x86Reg x86Pointer) void CX86Ops::fpuSubDwordReverse(void *Variable, const char * VariableName) { CPU_Message(" fsubr ST(0), dword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x2DD8); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x2DD8); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuSubQword(void *Variable, const char * VariableName) { CPU_Message(" fsub ST(0), qword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x25DC); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x25DC); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuSubQwordRegPointer(x86Reg x86Pointer) { CPU_Message(" fsub ST(0), qword ptr [%s]", x86_Name(x86Pointer)); switch (x86Pointer) { - case x86_EAX: PUTDST16(m_RecompPos, 0x20DC); break; - case x86_EBX: PUTDST16(m_RecompPos, 0x23DC); break; - case x86_ECX: PUTDST16(m_RecompPos, 0x21DC); break; - case x86_EDX: PUTDST16(m_RecompPos, 0x22DC); break; - case x86_ESI: PUTDST16(m_RecompPos, 0x26DC); break; - case x86_EDI: PUTDST16(m_RecompPos, 0x27DC); break; + case x86_EAX: AddCode16(0x20DC); break; + case x86_EBX: AddCode16(0x23DC); break; + case x86_ECX: AddCode16(0x21DC); break; + case x86_EDX: AddCode16(0x22DC); break; + case x86_ESI: AddCode16(0x26DC); break; + case x86_EDI: AddCode16(0x27DC); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -4128,22 +4131,22 @@ void CX86Ops::fpuSubQwordRegPointer(x86Reg x86Pointer) void CX86Ops::fpuSubQwordReverse(void *Variable, const char * VariableName) { CPU_Message(" fsubr ST(0), qword ptr [%s]", VariableName); - PUTDST16(m_RecompPos, 0x2DDC); - PUTDST32(m_RecompPos, Variable); + AddCode16(0x2DDC); + AddCode32((uint32_t)Variable); } void CX86Ops::fpuSubReg(x86FpuValues x86reg) { CPU_Message(" fsub ST(0), %s", fpu_Name(x86reg)); switch (x86reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xE0D8); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xE1D8); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xE2D8); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xE3D8); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xE4D8); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xE5D8); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xE6D8); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xE7D8); break; + case x86_ST0: AddCode16(0xE0D8); break; + case x86_ST1: AddCode16(0xE1D8); break; + case x86_ST2: AddCode16(0xE2D8); break; + case x86_ST3: AddCode16(0xE3D8); break; + case x86_ST4: AddCode16(0xE4D8); break; + case x86_ST5: AddCode16(0xE5D8); break; + case x86_ST6: AddCode16(0xE6D8); break; + case x86_ST7: AddCode16(0xE7D8); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -4154,14 +4157,14 @@ void CX86Ops::fpuSubRegPop(x86FpuValues x86reg) { CPU_Message(" fsubp ST(0), %s", fpu_Name(x86reg)); switch (x86reg) { - case x86_ST0: PUTDST16(m_RecompPos, 0xE8DE); break; - case x86_ST1: PUTDST16(m_RecompPos, 0xE9DE); break; - case x86_ST2: PUTDST16(m_RecompPos, 0xEADE); break; - case x86_ST3: PUTDST16(m_RecompPos, 0xEBDE); break; - case x86_ST4: PUTDST16(m_RecompPos, 0xECDE); break; - case x86_ST5: PUTDST16(m_RecompPos, 0xEDDE); break; - case x86_ST6: PUTDST16(m_RecompPos, 0xEEDE); break; - case x86_ST7: PUTDST16(m_RecompPos, 0xEFDE); break; + case x86_ST0: AddCode16(0xE8DE); break; + case x86_ST1: AddCode16(0xE9DE); break; + case x86_ST2: AddCode16(0xEADE); break; + case x86_ST3: AddCode16(0xEBDE); break; + case x86_ST4: AddCode16(0xECDE); break; + case x86_ST5: AddCode16(0xEDDE); break; + case x86_ST6: AddCode16(0xEEDE); break; + case x86_ST7: AddCode16(0xEFDE); break; default: g_Notify->BreakPoint(__FILE__, __LINE__); break; @@ -4287,4 +4290,22 @@ void * CX86Ops::GetAddressOf(int value, ...) va_end(ap); return Address; -} \ No newline at end of file +} + +void CX86Ops::AddCode8(uint8_t value) +{ + (*((uint8_t *)(m_RecompPos)) = (uint8_t)(value)); + m_RecompPos += 1; +} + +void CX86Ops::AddCode16(uint16_t value) +{ + (*((uint16_t *)(m_RecompPos)) = (uint16_t)(value)); + m_RecompPos += 2; +} + +void CX86Ops::AddCode32(uint32_t value) +{ + (*((uint32_t *)(m_RecompPos)) = (uint32_t)(value)); + m_RecompPos += 4; +} diff --git a/Source/Project64-core/N64System/Recompiler/x86/x86ops.h b/Source/Project64-core/N64System/Recompiler/x86/x86ops.h index 5afeedb3d..a68588825 100644 --- a/Source/Project64-core/N64System/Recompiler/x86/x86ops.h +++ b/Source/Project64-core/N64System/Recompiler/x86/x86ops.h @@ -299,6 +299,9 @@ protected: private: static void BreakPointNotification(const char * FileName, int32_t LineNumber); static char m_fpupop[2][2]; + static void AddCode8(uint8_t value); + static void AddCode16(uint16_t value); + static void AddCode32(uint32_t value); }; #define AddressOf(Addr) CX86Ops::GetAddressOf(5,(Addr))