//*****************************************************************************
// movsx dst, src (e.g. movsx eax, al)
//*****************************************************************************
void CAssemblyWriterX86::MOVSX8( EIntelReg idst, EIntelReg isrc )
{
DAEDALUS_ASSERT( IsValidMov8Reg( isrc ), "Invalid source register for 8 bit move" );
EmitBYTE(0x0F);
EmitBYTE(0xBE);
EmitBYTE(0xC0 | (idst<<3) | isrc);
}
//*****************************************************************************
// 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);
}
//*****************************************************************************
// mov byte ptr mem, data
//*****************************************************************************
void CAssemblyWriterX86::MOVI_MEM8(void * mem, u8 data)
{
EmitBYTE(0xc6);
EmitBYTE(0x05);
EmitDWORD((u32)mem);
EmitBYTE(data);
}
//*****************************************************************************
// cmp dword ptr p_mem, data
//*****************************************************************************
void CAssemblyWriterX86::CMP_MEM32_I8(const void *p_mem, u8 data)
{
EmitBYTE(0x83);
EmitBYTE(0x3d);
EmitDWORD(reinterpret_cast< u32 >( p_mem ));
EmitBYTE(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);
}
//*****************************************************************************
// mov dst, byte ptr [base]
//*****************************************************************************
void CAssemblyWriterX86::MOV8_REG_MEM_BASE( EIntelReg idst, EIntelReg ibase )
{
DAEDALUS_ASSERT( IsValidMov8Reg( idst ), "Invalid destination register for 8 bit move" );
EmitBYTE(0x8A);
EmitBYTE(0x00 | (idst<<3) | ibase);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::AND(EIntelReg reg1, EIntelReg reg2)
{
if (reg1 != reg2)
{
EmitBYTE(0x23);
EmitBYTE(0xc0 | (reg1<<3) | reg2);
}
}
//*****************************************************************************
// movzx reg1, reg2
//*****************************************************************************
void CAssemblyWriterX86::MOVZX(EIntelReg reg1, EIntelReg reg2, bool _8bit)
{
EmitBYTE(0x0f);
if (_8bit)
EmitBYTE(0xB6);
else
EmitBYTE(0xB7);
EmitBYTE(0xc0 | (reg1<<3) | reg2);
}
//*****************************************************************************
// 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);
}
//*****************************************************************************
//
//*****************************************************************************
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);
}
//*****************************************************************************
// 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);
}
}
//*****************************************************************************
//
//*****************************************************************************
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;
}
//*****************************************************************************
//
//*****************************************************************************
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;
}
//*****************************************************************************
// 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::CDQ()
{
EmitBYTE(0x99);
}
//*****************************************************************************
// movsx dst, src (e.g. movsx eax, ax)
//*****************************************************************************
void CAssemblyWriterX86::MOVSX16( EIntelReg idst, EIntelReg isrc )
{
EmitBYTE(0x0F);
EmitBYTE(0xBF);
EmitBYTE(0xC0 | (idst<<3) | isrc);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::MUL(EIntelReg reg)
{
EmitBYTE(0xf7);
EmitBYTE(0xe0 | reg);
}
//*****************************************************************************
//
//*****************************************************************************
void CAssemblyWriterX86::MOVI(EIntelReg reg, u32 data)
{
EmitBYTE(0xB8 | reg);
EmitDWORD(data);
}
//*****************************************************************************
// mov dst, dword ptr [base]
//*****************************************************************************
void CAssemblyWriterX86::MOV_REG_MEM_BASE( EIntelReg idst, EIntelReg ibase )
{
EmitBYTE(0x8B);
EmitBYTE(0x00 | (idst<<3) | ibase);
}
//*****************************************************************************
// mov dst, dword ptr [base + nn]
//*****************************************************************************
void CAssemblyWriterX86::MOV_REG_MEM_BASE_OFFSET8( EIntelReg idst, EIntelReg ibase, s8 offset )
{
EmitBYTE(0x8B);
EmitBYTE(0x40 | (idst<<3) | ibase);
EmitBYTE((u8)offset);
}
//*****************************************************************************
// 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], src
//*****************************************************************************
void CAssemblyWriterX86::MOV_MEM_BASE_REG( EIntelReg ibase, EIntelReg isrc )
{
EmitBYTE(0x89);
EmitBYTE(0x00 | (isrc<<3) | ibase);
}
//*****************************************************************************
// mov dword ptr [base + nn], src
//*****************************************************************************
void CAssemblyWriterX86::MOV_MEM_BASE_OFFSET8_REG( EIntelReg ibase, s8 offset, EIntelReg isrc )
{
EmitBYTE(0x89);
EmitBYTE(0x40 | (isrc<<3) | ibase);
EmitBYTE((u8)offset);
}
//*****************************************************************************
// mov byte ptr [base], src
//*****************************************************************************
void CAssemblyWriterX86::MOV8_MEM_BASE_REG( EIntelReg ibase, EIntelReg isrc )
{
DAEDALUS_ASSERT( IsValidMov8Reg( isrc ), "Invalid source register for 8 bit move" );
EmitBYTE(0x88);
EmitBYTE(0x00 | (isrc<<3) | ibase);
}
