//*****************************************************************************
// cmp dword ptr p_mem, data
//*****************************************************************************
void CAssemblyWriterX86::CMP_MEM32_I32(const void *p_mem, u32 data)
{
EmitBYTE(0x81);
EmitBYTE(0x3d);
EmitDWORD(reinterpret_cast< u32 >( p_mem ));
EmitDWORD(data);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::MOVI_MEM(void * mem, u32 data)
{
EmitBYTE(0xc7);
EmitBYTE(0x05);
EmitDWORD((u32)mem);
EmitDWORD(data);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::ADD_REG_MEM_IDXx4( EIntelReg destreg, void * mem, EIntelReg idxreg )
{
EmitBYTE(0x03);
EmitBYTE(0x04 | (destreg << 3));
EmitBYTE(0x85 | (idxreg<<3));
EmitDWORD((u32)mem);
}
//*****************************************************************************
// call dword ptr [mem + reg*4]
//*****************************************************************************
void CAssemblyWriterX86::CALL_MEM_PLUS_REGx4( void * mem, EIntelReg reg )
{
EmitBYTE(0xFF);
EmitBYTE(0x14);
EmitBYTE(0x85 | (reg<<3));
EmitDWORD((u32)mem);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::XOR_I32(EIntelReg reg, u32 data)
{
/*if (reg == EAX_CODE)
EmitBYTE(0x35);
else */
{
EmitBYTE(0x81);
EmitBYTE(0xf0 | reg);
}
EmitDWORD(data);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::ORI(EIntelReg reg, u32 data)
{
/*if (reg == EAX_CODE)
EmitBYTE(0x0D);
else*/
{
EmitBYTE(0x81);
EmitBYTE(0xc8 | reg);
}
EmitDWORD(data);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::FLD_MEMp64( void * memlo, void * memhi )
{
static s64 longtemp;
MOV_REG_MEM(EAX_CODE, (u8*)(memlo) );
MOV_REG_MEM(EDX_CODE, (u8*)(memhi) );
MOV_MEM_REG(((u8*)&longtemp) + 0, EAX_CODE);
MOV_MEM_REG(((u8*)&longtemp) + 4, EDX_CODE);
EmitWORD(0x05dd);
EmitDWORD( u32(&longtemp) );
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::FSTP_MEMp64( void * memlo, void * memhi )
{
static s64 longtemp;
EmitWORD(0x1ddd);
EmitDWORD( u32(&longtemp) );
MOV_REG_MEM(EAX_CODE, ((u8*)(&longtemp))+0);
MOV_REG_MEM(EDX_CODE, ((u8*)(&longtemp))+4);
MOV_MEM_REG(((u8*)(memlo)), EAX_CODE);
MOV_MEM_REG(((u8*)(memhi)), EDX_CODE);
}
//*****************************************************************************
// mov dword ptr[ mem ], reg
//*****************************************************************************
void CAssemblyWriterX86::MOV_MEM_REG(void * mem, EIntelReg isrc)
{
/*if (reg == EAX_CODE)
EmitBYTE(0xa3);
else*/
{
EmitBYTE(0x89);
EmitBYTE((isrc<<3) | 0x05);
}
EmitDWORD((u32)mem);
}
//*****************************************************************************
//
//*****************************************************************************
CJumpLocation CAssemblyWriterX86::JMPLong( CCodeLabel target )
{
const u32 JUMP_DIRECT_LONG_LENGTH = 5;
CJumpLocation jump_location( mpAssemblyBuffer->GetJumpLocation() );
s32 offset( jump_location.GetOffset( target ) - JUMP_DIRECT_LONG_LENGTH );
EmitBYTE(0xe9);
EmitDWORD( static_cast< u32 >( offset ) );
return jump_location;
}
//*****************************************************************************
//
//*****************************************************************************
CJumpLocation CAssemblyWriterX86::CALL( CCodeLabel target )
{
const u32 CALL_LONG_LENGTH = 5;
CJumpLocation jump_location( mpAssemblyBuffer->GetJumpLocation() );
s32 offset( jump_location.GetOffset( target ) - CALL_LONG_LENGTH );
EmitBYTE( 0xe8 );
EmitDWORD( offset );
return jump_location;
}
//*****************************************************************************
// mov reg, dword ptr[ mem ]
//*****************************************************************************
void CAssemblyWriterX86::MOV_REG_MEM(EIntelReg reg, const void * mem)
{
/*if (reg == EAX_CODE)
EmitBYTE(0xa1);
else*/
{
EmitBYTE(0x8b);
EmitBYTE((reg<<3) | 0x05);
}
EmitDWORD((u32)mem);
}
//*****************************************************************************
//
//*****************************************************************************
CJumpLocation CAssemblyWriterX86::JumpConditionalLong( CCodeLabel target, u8 jump_type )
{
const u32 JUMP_LONG_LENGTH = 6;
CJumpLocation jump_location( mpAssemblyBuffer->GetJumpLocation() );
s32 offset( jump_location.GetOffset( target ) - JUMP_LONG_LENGTH );
EmitBYTE( 0x0f );
EmitBYTE( jump_type ); //
EmitDWORD( offset );
return jump_location;
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::ADDI(EIntelReg reg, s32 data)
{
if (data == 0)
return;
/*if (reg == EAX_CODE)
EmitBYTE(0x05);
else */
{
EmitBYTE(0x81);
EmitBYTE(0xc0 | reg);
}
EmitDWORD(data);
}
//*****************************************************************************
// Use short form (0x83c0) if data is just one byte!
//*****************************************************************************
void CAssemblyWriterX86::ADDI(EIntelReg reg, s32 data)
{
if (data == 0)
return;
if (data <= 127 && data > -127)
{
EmitBYTE(0x83);
EmitBYTE(0xc0 | reg);
EmitBYTE((u8)data);
}
else
{
EmitBYTE(0x81);
EmitBYTE(0xc0 | reg);
EmitDWORD(data);
}
}
//*****************************************************************************
// Use short form (0x83d0) if data is just one byte!
//*****************************************************************************
void CAssemblyWriterX86::ADCI(EIntelReg reg, s32 data)
{
/*if (reg == EAX_CODE)
{
EmitBYTE(0x15);
EmitDWORD(data)
}
else*/
if (data <= 127 && data > -127)
{
EmitBYTE(0x83);
EmitBYTE(0xd0 | reg);
EmitBYTE((u8)(data));
}
else
{
EmitBYTE(0x81);
EmitBYTE(0xd0 | reg);
EmitDWORD(data);
}
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::FISTP_MEMp( void * pmem )
{
EmitWORD( 0x1ddb );
EmitDWORD((u32)pmem);
}
//*****************************************************************************
// and eax, 0x00FF - Mask off top bits!
// This is slightly more efficient than ANDI( EAX_CODE, data )
//*****************************************************************************
void CAssemblyWriterX86::AND_EAX( u32 mask )
{
EmitBYTE(0x25);
EmitDWORD(mask);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::FSTP_MEMp32( void * pmem )
{
EmitWORD( 0x1dd9);
EmitDWORD( u32(pmem) );
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::FILD_MEM( void * pmem )
{
EmitWORD(0x05db);
EmitDWORD( u32(pmem) );
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::FLD_MEMp32( void * pmem )
{
EmitWORD(0x05d9);
EmitDWORD( u32(pmem) );
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::MOVI(EIntelReg reg, u32 data)
{
EmitBYTE(0xB8 | reg);
EmitDWORD(data);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::CMPI(EIntelReg reg, u32 data)
{
EmitBYTE(0x81);
EmitBYTE(0xf8 | reg);
EmitDWORD(data);
}
//*****************************************************************************
// mov dst, dword ptr [base + nnnnnnnn]
//*****************************************************************************
void CAssemblyWriterX86::MOV_REG_MEM_BASE_OFFSET32( EIntelReg idst, EIntelReg ibase, s32 offset )
{
EmitBYTE(0x8B);
EmitBYTE(0x80 | (idst<<3) | ibase);
EmitDWORD((u32)offset);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::MUL_EAX_MEM(void * mem)
{
EmitBYTE(0xf7);
EmitBYTE(0x25);
EmitDWORD((u32)mem);
}
//*****************************************************************************
// mov dword ptr [base + nnnnnnnn], src
//*****************************************************************************
void CAssemblyWriterX86::MOV_MEM_BASE_OFFSET32_REG( EIntelReg ibase, s32 offset, EIntelReg isrc )
{
EmitBYTE(0x89);
EmitBYTE(0x80 | (isrc<<3) | ibase);
EmitDWORD((u32)offset);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::JS(s32 off)
{
EmitBYTE(0x0f);
EmitBYTE(0x88);
EmitDWORD( u32(off) );
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::PUSHI( u32 value )
{
EmitBYTE( 0x68 );
EmitDWORD( value );
}
