mirror of https://github.com/PCSX2/pcsx2.git
522 lines
23 KiB
C++
522 lines
23 KiB
C++
/* PCSX2 - PS2 Emulator for PCs
|
|
* Copyright (C) 2002-2009 PCSX2 Dev Team
|
|
*
|
|
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU Lesser General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with PCSX2.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* ix86 definitions v0.9.0
|
|
*
|
|
* Original Authors (v0.6.2 and prior):
|
|
* linuzappz <linuzappz@pcsx.net>
|
|
* alexey silinov
|
|
* goldfinger
|
|
* zerofrog(@gmail.com)
|
|
*
|
|
* Authors of v0.9.0:
|
|
* Jake.Stine(@gmail.com)
|
|
* cottonvibes(@gmail.com)
|
|
* sudonim(1@gmail.com)
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
namespace x86Emitter
|
|
{
|
|
extern void xStoreReg( const xRegisterSSE& src );
|
|
extern void xRestoreReg( const xRegisterSSE& dest );
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Group 1 Instruction Class
|
|
|
|
extern const Internal::xImpl_G1Logic<Internal::G1Type_AND,0x54> xAND;
|
|
extern const Internal::xImpl_G1Logic<Internal::G1Type_OR,0x56> xOR;
|
|
extern const Internal::xImpl_G1Logic<Internal::G1Type_XOR,0x57> xXOR;
|
|
|
|
extern const Internal::xImpl_G1Arith<Internal::G1Type_ADD,0x58> xADD;
|
|
extern const Internal::xImpl_G1Arith<Internal::G1Type_SUB,0x5c> xSUB;
|
|
extern const Internal::xImpl_G1Compare xCMP;
|
|
|
|
extern const Internal::xImpl_Group1<Internal::G1Type_ADC> xADC;
|
|
extern const Internal::xImpl_Group1<Internal::G1Type_SBB> xSBB;
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Group 2 Instruction Class
|
|
//
|
|
// Optimization Note: For Imm forms, we ignore the instruction if the shift count is
|
|
// zero. This is a safe optimization since any zero-value shift does not affect any
|
|
// flags.
|
|
|
|
extern const Internal::MovImplAll xMOV;
|
|
extern const Internal::xImpl_Test xTEST;
|
|
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_ROL> xROL;
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_ROR> xROR;
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_RCL> xRCL;
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_RCR> xRCR;
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_SHL> xSHL;
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_SHR> xSHR;
|
|
extern const Internal::Group2ImplAll<Internal::G2Type_SAR> xSAR;
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Group 3 Instruction Class
|
|
|
|
extern const Internal::xImpl_Group3<Internal::G3Type_NOT> xNOT;
|
|
extern const Internal::xImpl_Group3<Internal::G3Type_NEG> xNEG;
|
|
extern const Internal::xImpl_Group3<Internal::G3Type_MUL> xUMUL;
|
|
extern const Internal::xImpl_Group3<Internal::G3Type_DIV> xUDIV;
|
|
extern const Internal::xImpl_iDiv xDIV;
|
|
extern const Internal::xImpl_iMul xMUL;
|
|
|
|
extern const Internal::xImpl_IncDec<false> xINC;
|
|
extern const Internal::xImpl_IncDec<true> xDEC;
|
|
|
|
extern const Internal::MovExtendImplAll<false> xMOVZX;
|
|
extern const Internal::MovExtendImplAll<true> xMOVSX;
|
|
|
|
extern const Internal::DwordShiftImplAll<false> xSHLD;
|
|
extern const Internal::DwordShiftImplAll<true> xSHRD;
|
|
|
|
extern const Internal::xImpl_Group8<Internal::G8Type_BT> xBT;
|
|
extern const Internal::xImpl_Group8<Internal::G8Type_BTR> xBTR;
|
|
extern const Internal::xImpl_Group8<Internal::G8Type_BTS> xBTS;
|
|
extern const Internal::xImpl_Group8<Internal::G8Type_BTC> xBTC;
|
|
|
|
extern const Internal::xImpl_JmpCall<true> xJMP;
|
|
extern const Internal::xImpl_JmpCall<false> xCALL;
|
|
|
|
extern const Internal::xImpl_BitScan<0xbc> xBSF;
|
|
extern const Internal::xImpl_BitScan<0xbd> xBSR;
|
|
|
|
// ------------------------------------------------------------------------
|
|
extern const Internal::CMovImplGeneric xCMOV;
|
|
|
|
extern const Internal::CMovImplAll<Jcc_Above> xCMOVA;
|
|
extern const Internal::CMovImplAll<Jcc_AboveOrEqual> xCMOVAE;
|
|
extern const Internal::CMovImplAll<Jcc_Below> xCMOVB;
|
|
extern const Internal::CMovImplAll<Jcc_BelowOrEqual> xCMOVBE;
|
|
|
|
extern const Internal::CMovImplAll<Jcc_Greater> xCMOVG;
|
|
extern const Internal::CMovImplAll<Jcc_GreaterOrEqual> xCMOVGE;
|
|
extern const Internal::CMovImplAll<Jcc_Less> xCMOVL;
|
|
extern const Internal::CMovImplAll<Jcc_LessOrEqual> xCMOVLE;
|
|
|
|
extern const Internal::CMovImplAll<Jcc_Zero> xCMOVZ;
|
|
extern const Internal::CMovImplAll<Jcc_Equal> xCMOVE;
|
|
extern const Internal::CMovImplAll<Jcc_NotZero> xCMOVNZ;
|
|
extern const Internal::CMovImplAll<Jcc_NotEqual> xCMOVNE;
|
|
|
|
extern const Internal::CMovImplAll<Jcc_Overflow> xCMOVO;
|
|
extern const Internal::CMovImplAll<Jcc_NotOverflow> xCMOVNO;
|
|
extern const Internal::CMovImplAll<Jcc_Carry> xCMOVC;
|
|
extern const Internal::CMovImplAll<Jcc_NotCarry> xCMOVNC;
|
|
|
|
extern const Internal::CMovImplAll<Jcc_Signed> xCMOVS;
|
|
extern const Internal::CMovImplAll<Jcc_Unsigned> xCMOVNS;
|
|
extern const Internal::CMovImplAll<Jcc_ParityEven> xCMOVPE;
|
|
extern const Internal::CMovImplAll<Jcc_ParityOdd> xCMOVPO;
|
|
|
|
// ------------------------------------------------------------------------
|
|
extern const Internal::SetImplGeneric xSET;
|
|
|
|
extern const Internal::SetImplAll<Jcc_Above> xSETA;
|
|
extern const Internal::SetImplAll<Jcc_AboveOrEqual> xSETAE;
|
|
extern const Internal::SetImplAll<Jcc_Below> xSETB;
|
|
extern const Internal::SetImplAll<Jcc_BelowOrEqual> xSETBE;
|
|
|
|
extern const Internal::SetImplAll<Jcc_Greater> xSETG;
|
|
extern const Internal::SetImplAll<Jcc_GreaterOrEqual> xSETGE;
|
|
extern const Internal::SetImplAll<Jcc_Less> xSETL;
|
|
extern const Internal::SetImplAll<Jcc_LessOrEqual> xSETLE;
|
|
|
|
extern const Internal::SetImplAll<Jcc_Zero> xSETZ;
|
|
extern const Internal::SetImplAll<Jcc_Equal> xSETE;
|
|
extern const Internal::SetImplAll<Jcc_NotZero> xSETNZ;
|
|
extern const Internal::SetImplAll<Jcc_NotEqual> xSETNE;
|
|
|
|
extern const Internal::SetImplAll<Jcc_Overflow> xSETO;
|
|
extern const Internal::SetImplAll<Jcc_NotOverflow> xSETNO;
|
|
extern const Internal::SetImplAll<Jcc_Carry> xSETC;
|
|
extern const Internal::SetImplAll<Jcc_NotCarry> xSETNC;
|
|
|
|
extern const Internal::SetImplAll<Jcc_Signed> xSETS;
|
|
extern const Internal::SetImplAll<Jcc_Unsigned> xSETNS;
|
|
extern const Internal::SetImplAll<Jcc_ParityEven> xSETPE;
|
|
extern const Internal::SetImplAll<Jcc_ParityOdd> xSETPO;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Miscellaneous Instructions
|
|
// These are all defined inline or in ix86.cpp.
|
|
//
|
|
|
|
extern void xBSWAP( const xRegister32& to );
|
|
|
|
// ----- Lea Instructions (Load Effective Address) -----
|
|
// Note: alternate (void*) forms of these instructions are not provided since those
|
|
// forms are functionally equivalent to Mov reg,imm, and thus better written as MOVs
|
|
// instead.
|
|
|
|
extern void xLEA( xRegister32 to, const ModSibBase& src, bool preserve_flags=false );
|
|
extern void xLEA( xRegister16 to, const ModSibBase& src, bool preserve_flags=false );
|
|
|
|
// ----- Push / Pop Instructions -----
|
|
// Note: pushad/popad implementations are intentionally left out. The instructions are
|
|
// invalid in x64, and are super slow on x32. Use multiple Push/Pop instructions instead.
|
|
|
|
extern void xPOP( const ModSibBase& from );
|
|
extern void xPUSH( const ModSibBase& from );
|
|
|
|
extern void xPOP( xRegister32 from );
|
|
|
|
extern void xPUSH( u32 imm );
|
|
extern void xPUSH( xRegister32 from );
|
|
|
|
// pushes the EFLAGS register onto the stack
|
|
extern void xPUSHFD();
|
|
// pops the EFLAGS register from the stack
|
|
extern void xPOPFD();
|
|
|
|
// ----- Miscellaneous Instructions -----
|
|
// Various Instructions with no parameter and no special encoding logic.
|
|
|
|
extern void xRET();
|
|
extern void xCBW();
|
|
extern void xCWD();
|
|
extern void xCDQ();
|
|
extern void xCWDE();
|
|
|
|
extern void xLAHF();
|
|
extern void xSAHF();
|
|
|
|
extern void xSTC();
|
|
extern void xCLC();
|
|
|
|
// NOP 1-byte
|
|
extern void xNOP();
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// JMP / Jcc Instructions!
|
|
|
|
extern void xJcc( JccComparisonType comparison, const void* target );
|
|
extern s8* xJcc8( JccComparisonType comparison=Jcc_Unconditional, s8 displacement=0 );
|
|
extern s32* xJcc32( JccComparisonType comparison=Jcc_Unconditional, s32 displacement=0 );
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Conditional jumps to fixed targets.
|
|
// Jumps accept any pointer as a valid target (function or data), and will generate either
|
|
// 8 or 32 bit displacement versions of the jump, depending on relative displacement of
|
|
// the target (efficient!)
|
|
//
|
|
|
|
template< typename T > __forceinline void xJE( T* func ) { xJcc( Jcc_Equal, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJZ( T* func ) { xJcc( Jcc_Zero, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJNE( T* func ) { xJcc( Jcc_NotEqual, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJNZ( T* func ) { xJcc( Jcc_NotZero, (void*)(uptr)func ); }
|
|
|
|
template< typename T > __forceinline void xJO( T* func ) { xJcc( Jcc_Overflow, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJNO( T* func ) { xJcc( Jcc_NotOverflow, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJC( T* func ) { xJcc( Jcc_Carry, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJNC( T* func ) { xJcc( Jcc_NotCarry, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJS( T* func ) { xJcc( Jcc_Signed, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJNS( T* func ) { xJcc( Jcc_Unsigned, (void*)(uptr)func ); }
|
|
|
|
template< typename T > __forceinline void xJPE( T* func ) { xJcc( Jcc_ParityEven, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJPO( T* func ) { xJcc( Jcc_ParityOdd, (void*)(uptr)func ); }
|
|
|
|
template< typename T > __forceinline void xJL( T* func ) { xJcc( Jcc_Less, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJLE( T* func ) { xJcc( Jcc_LessOrEqual, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJG( T* func ) { xJcc( Jcc_Greater, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJGE( T* func ) { xJcc( Jcc_GreaterOrEqual, (void*)(uptr)func ); }
|
|
|
|
template< typename T > __forceinline void xJB( T* func ) { xJcc( Jcc_Below, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJBE( T* func ) { xJcc( Jcc_BelowOrEqual, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJA( T* func ) { xJcc( Jcc_Above, (void*)(uptr)func ); }
|
|
template< typename T > __forceinline void xJAE( T* func ) { xJcc( Jcc_AboveOrEqual, (void*)(uptr)func ); }
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Forward Jump Helpers (act as labels!)
|
|
|
|
#define DEFINE_FORWARD_JUMP( label, cond ) \
|
|
template< typename OperandType > \
|
|
class xForward##label : public xForwardJump<OperandType> \
|
|
{ \
|
|
public: \
|
|
xForward##label() : xForwardJump<OperandType>( cond ) {} \
|
|
};
|
|
|
|
// ------------------------------------------------------------------------
|
|
// Note: typedefs below are defined individually in order to appease Intellisense
|
|
// resolution. Including them into the class definition macro above breaks it.
|
|
|
|
typedef xForwardJump<s8> xForwardJump8;
|
|
typedef xForwardJump<s32> xForwardJump32;
|
|
|
|
DEFINE_FORWARD_JUMP( JA, Jcc_Above );
|
|
DEFINE_FORWARD_JUMP( JB, Jcc_Below );
|
|
DEFINE_FORWARD_JUMP( JAE, Jcc_AboveOrEqual );
|
|
DEFINE_FORWARD_JUMP( JBE, Jcc_BelowOrEqual );
|
|
|
|
typedef xForwardJA<s8> xForwardJA8;
|
|
typedef xForwardJA<s32> xForwardJA32;
|
|
typedef xForwardJB<s8> xForwardJB8;
|
|
typedef xForwardJB<s32> xForwardJB32;
|
|
typedef xForwardJAE<s8> xForwardJAE8;
|
|
typedef xForwardJAE<s32> xForwardJAE32;
|
|
typedef xForwardJBE<s8> xForwardJBE8;
|
|
typedef xForwardJBE<s32> xForwardJBE32;
|
|
|
|
DEFINE_FORWARD_JUMP( JG, Jcc_Greater );
|
|
DEFINE_FORWARD_JUMP( JL, Jcc_Less );
|
|
DEFINE_FORWARD_JUMP( JGE, Jcc_GreaterOrEqual );
|
|
DEFINE_FORWARD_JUMP( JLE, Jcc_LessOrEqual );
|
|
|
|
typedef xForwardJG<s8> xForwardJG8;
|
|
typedef xForwardJG<s32> xForwardJG32;
|
|
typedef xForwardJL<s8> xForwardJL8;
|
|
typedef xForwardJL<s32> xForwardJL32;
|
|
typedef xForwardJGE<s8> xForwardJGE8;
|
|
typedef xForwardJGE<s32> xForwardJGE32;
|
|
typedef xForwardJLE<s8> xForwardJLE8;
|
|
typedef xForwardJLE<s32> xForwardJLE32;
|
|
|
|
DEFINE_FORWARD_JUMP( JZ, Jcc_Zero );
|
|
DEFINE_FORWARD_JUMP( JE, Jcc_Equal );
|
|
DEFINE_FORWARD_JUMP( JNZ, Jcc_NotZero );
|
|
DEFINE_FORWARD_JUMP( JNE, Jcc_NotEqual );
|
|
|
|
typedef xForwardJZ<s8> xForwardJZ8;
|
|
typedef xForwardJZ<s32> xForwardJZ32;
|
|
typedef xForwardJE<s8> xForwardJE8;
|
|
typedef xForwardJE<s32> xForwardJE32;
|
|
typedef xForwardJNZ<s8> xForwardJNZ8;
|
|
typedef xForwardJNZ<s32> xForwardJNZ32;
|
|
typedef xForwardJNE<s8> xForwardJNE8;
|
|
typedef xForwardJNE<s32> xForwardJNE32;
|
|
|
|
DEFINE_FORWARD_JUMP( JS, Jcc_Signed );
|
|
DEFINE_FORWARD_JUMP( JNS, Jcc_Unsigned );
|
|
|
|
typedef xForwardJS<s8> xForwardJS8;
|
|
typedef xForwardJS<s32> xForwardJS32;
|
|
typedef xForwardJNS<s8> xForwardJNS8;
|
|
typedef xForwardJNS<s32> xForwardJNS32;
|
|
|
|
DEFINE_FORWARD_JUMP( JO, Jcc_Overflow );
|
|
DEFINE_FORWARD_JUMP( JNO, Jcc_NotOverflow );
|
|
|
|
typedef xForwardJO<s8> xForwardJO8;
|
|
typedef xForwardJO<s32> xForwardJO32;
|
|
typedef xForwardJNO<s8> xForwardJNO8;
|
|
typedef xForwardJNO<s32> xForwardJNO32;
|
|
|
|
DEFINE_FORWARD_JUMP( JC, Jcc_Carry );
|
|
DEFINE_FORWARD_JUMP( JNC, Jcc_NotCarry );
|
|
|
|
typedef xForwardJC<s8> xForwardJC8;
|
|
typedef xForwardJC<s32> xForwardJC32;
|
|
typedef xForwardJNC<s8> xForwardJNC8;
|
|
typedef xForwardJNC<s32> xForwardJNC32;
|
|
|
|
DEFINE_FORWARD_JUMP( JPE, Jcc_ParityEven );
|
|
DEFINE_FORWARD_JUMP( JPO, Jcc_ParityOdd );
|
|
|
|
typedef xForwardJPE<s8> xForwardJPE8;
|
|
typedef xForwardJPE<s32> xForwardJPE32;
|
|
typedef xForwardJPO<s8> xForwardJPO8;
|
|
typedef xForwardJPO<s32> xForwardJPO32;
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
extern void xEMMS();
|
|
extern void xSTMXCSR( u32* dest );
|
|
extern void xLDMXCSR( const u32* src );
|
|
|
|
extern void xMOVDZX( const xRegisterSSE& to, const xRegister32& from );
|
|
extern void xMOVDZX( const xRegisterSSE& to, const ModSibBase& src );
|
|
|
|
extern void xMOVDZX( const xRegisterMMX& to, const xRegister32& from );
|
|
extern void xMOVDZX( const xRegisterMMX& to, const ModSibBase& src );
|
|
|
|
extern void xMOVD( const xRegister32& to, const xRegisterSSE& from );
|
|
extern void xMOVD( const ModSibBase& dest, const xRegisterSSE& from );
|
|
|
|
extern void xMOVD( const xRegister32& to, const xRegisterMMX& from );
|
|
extern void xMOVD( const ModSibBase& dest, const xRegisterMMX& from );
|
|
|
|
extern void xMOVQ( const xRegisterMMX& to, const xRegisterMMX& from );
|
|
extern void xMOVQ( const xRegisterMMX& to, const xRegisterSSE& from );
|
|
extern void xMOVQ( const xRegisterSSE& to, const xRegisterMMX& from );
|
|
|
|
extern void xMOVQ( const ModSibBase& dest, const xRegisterSSE& from );
|
|
extern void xMOVQ( const ModSibBase& dest, const xRegisterMMX& from );
|
|
extern void xMOVQ( const xRegisterMMX& to, const ModSibBase& src );
|
|
|
|
extern void xMOVQZX( const xRegisterSSE& to, const ModSibBase& src );
|
|
extern void xMOVQZX( const xRegisterSSE& to, const xRegisterSSE& from );
|
|
|
|
extern void xMOVSS( const xRegisterSSE& to, const xRegisterSSE& from );
|
|
extern void xMOVSS( const ModSibBase& to, const xRegisterSSE& from );
|
|
extern void xMOVSD( const xRegisterSSE& to, const xRegisterSSE& from );
|
|
extern void xMOVSD( const ModSibBase& to, const xRegisterSSE& from );
|
|
|
|
extern void xMOVSSZX( const xRegisterSSE& to, const ModSibBase& from );
|
|
extern void xMOVSDZX( const xRegisterSSE& to, const ModSibBase& from );
|
|
|
|
extern void xMOVNTDQA( const xRegisterSSE& to, const ModSibBase& from );
|
|
extern void xMOVNTDQA( const ModSibBase& to, const xRegisterSSE& from );
|
|
|
|
extern void xMOVNTPD( const ModSibBase& to, const xRegisterSSE& from );
|
|
extern void xMOVNTPS( const ModSibBase& to, const xRegisterSSE& from );
|
|
extern void xMOVNTQ( const ModSibBase& to, const xRegisterMMX& from );
|
|
|
|
extern void xMOVMSKPS( const xRegister32& to, const xRegisterSSE& from );
|
|
extern void xMOVMSKPD( const xRegister32& to, const xRegisterSSE& from );
|
|
|
|
extern void xMASKMOV( const xRegisterSSE& to, const xRegisterSSE& from );
|
|
extern void xMASKMOV( const xRegisterMMX& to, const xRegisterMMX& from );
|
|
extern void xPMOVMSKB( const xRegister32& to, const xRegisterSSE& from );
|
|
extern void xPMOVMSKB( const xRegister32& to, const xRegisterMMX& from );
|
|
extern void xPALIGNR( const xRegisterSSE& to, const xRegisterSSE& from, u8 imm8 );
|
|
extern void xPALIGNR( const xRegisterMMX& to, const xRegisterMMX& from, u8 imm8 );
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
extern const Internal::SimdImpl_MoveSSE<0x00,true> xMOVAPS;
|
|
extern const Internal::SimdImpl_MoveSSE<0x00,false> xMOVUPS;
|
|
|
|
#ifdef ALWAYS_USE_MOVAPS
|
|
extern const Internal::SimdImpl_MoveSSE<0,true> xMOVDQA;
|
|
extern const Internal::SimdImpl_MoveSSE<0,false> xMOVDQU;
|
|
extern const Internal::SimdImpl_MoveSSE<0,true> xMOVAPD;
|
|
extern const Internal::SimdImpl_MoveSSE<0,false> xMOVUPD;
|
|
#else
|
|
extern const Internal::SimdImpl_MoveDQ<0x66, 0x6f, 0x7f> xMOVDQA;
|
|
extern const Internal::SimdImpl_MoveDQ<0xf3, 0x6f, 0x7f> xMOVDQU;
|
|
extern const Internal::SimdImpl_MoveSSE<0x66,true> xMOVAPD;
|
|
extern const Internal::SimdImpl_MoveSSE<0x66,false> xMOVUPD;
|
|
#endif
|
|
|
|
extern const Internal::MovhlImpl_RtoR<0x16> xMOVLH;
|
|
extern const Internal::MovhlImpl_RtoR<0x12> xMOVHL;
|
|
|
|
extern const Internal::MovhlImplAll<0x16> xMOVH;
|
|
extern const Internal::MovhlImplAll<0x12> xMOVL;
|
|
|
|
extern const Internal::SimdImpl_DestRegSSE<0xf3,0x12> xMOVSLDUP;
|
|
extern const Internal::SimdImpl_DestRegSSE<0xf3,0x16> xMOVSHDUP;
|
|
|
|
extern void xINSERTPS( const xRegisterSSE& to, const xRegisterSSE& from, u8 imm8 );
|
|
extern void xINSERTPS( const xRegisterSSE& to, const ModSibStrict<u32>& from, u8 imm8 );
|
|
|
|
extern void xEXTRACTPS( const xRegister32& to, const xRegisterSSE& from, u8 imm8 );
|
|
extern void xEXTRACTPS( const ModSibStrict<u32>& dest, const xRegisterSSE& from, u8 imm8 );
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
extern const Internal::SimdImpl_DestRegEither<0x66,0xdb> xPAND;
|
|
extern const Internal::SimdImpl_DestRegEither<0x66,0xdf> xPANDN;
|
|
extern const Internal::SimdImpl_DestRegEither<0x66,0xeb> xPOR;
|
|
extern const Internal::SimdImpl_DestRegEither<0x66,0xef> xPXOR;
|
|
|
|
extern const Internal::SimdImpl_AndNot xANDN;
|
|
|
|
extern const Internal::SimdImpl_COMI<true> xCOMI;
|
|
extern const Internal::SimdImpl_COMI<false> xUCOMI;
|
|
extern const Internal::SimdImpl_rSqrt<0x53> xRCP;
|
|
extern const Internal::SimdImpl_rSqrt<0x52> xRSQRT;
|
|
extern const Internal::SimdImpl_Sqrt<0x51> xSQRT;
|
|
|
|
extern const Internal::SimdImpl_MinMax<0x5f> xMAX;
|
|
extern const Internal::SimdImpl_MinMax<0x5d> xMIN;
|
|
extern const Internal::SimdImpl_Shuffle<0xc6> xSHUF;
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
extern const Internal::SimdImpl_DestRegSSE<0x66,0x1738> xPTEST;
|
|
|
|
extern const Internal::SimdImpl_Compare<SSE2_Equal> xCMPEQ;
|
|
extern const Internal::SimdImpl_Compare<SSE2_Less> xCMPLT;
|
|
extern const Internal::SimdImpl_Compare<SSE2_LessOrEqual> xCMPLE;
|
|
extern const Internal::SimdImpl_Compare<SSE2_Unordered> xCMPUNORD;
|
|
extern const Internal::SimdImpl_Compare<SSE2_NotEqual> xCMPNE;
|
|
extern const Internal::SimdImpl_Compare<SSE2_NotLess> xCMPNLT;
|
|
extern const Internal::SimdImpl_Compare<SSE2_NotLessOrEqual> xCMPNLE;
|
|
extern const Internal::SimdImpl_Compare<SSE2_Ordered> xCMPORD;
|
|
|
|
// ------------------------------------------------------------------------
|
|
// OMG Evil. I went cross-eyed an hour ago doing this.
|
|
//
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf3,0xe6,xRegisterSSE,xRegisterSSE,u64> xCVTDQ2PD;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x00,0x5b,xRegisterSSE,xRegisterSSE,u128> xCVTDQ2PS;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf2,0xe6,xRegisterSSE,xRegisterSSE,u128> xCVTPD2DQ;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x66,0x2d,xRegisterMMX,xRegisterSSE,u128> xCVTPD2PI;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x66,0x5a,xRegisterSSE,xRegisterSSE,u128> xCVTPD2PS;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0x66,0x2a,xRegisterSSE,xRegisterMMX,u64> xCVTPI2PD;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x00,0x2a,xRegisterSSE,xRegisterMMX,u64> xCVTPI2PS;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0x66,0x5b,xRegisterSSE,xRegisterSSE,u128> xCVTPS2DQ;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x00,0x5a,xRegisterSSE,xRegisterSSE,u64> xCVTPS2PD;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x00,0x2d,xRegisterMMX,xRegisterSSE,u64> xCVTPS2PI;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf2,0x2d,xRegister32, xRegisterSSE,u64> xCVTSD2SI;
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf2,0x5a,xRegisterSSE,xRegisterSSE,u64> xCVTSD2SS;
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf2,0x2a,xRegisterMMX,xRegister32, u32> xCVTSI2SD;
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf3,0x2a,xRegisterSSE,xRegister32, u32> xCVTSI2SS;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf3,0x5a,xRegisterSSE,xRegisterSSE,u32> xCVTSS2SD;
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf3,0x2d,xRegister32, xRegisterSSE,u32> xCVTSS2SI;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0x66,0xe6,xRegisterSSE,xRegisterSSE,u128> xCVTTPD2DQ;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x66,0x2c,xRegisterMMX,xRegisterSSE,u128> xCVTTPD2PI;
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf3,0x5b,xRegisterSSE,xRegisterSSE,u128> xCVTTPS2DQ;
|
|
extern const Internal::SimdImpl_DestRegStrict<0x00,0x2c,xRegisterMMX,xRegisterSSE,u64> xCVTTPS2PI;
|
|
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf2,0x2c,xRegister32, xRegisterSSE,u64> xCVTTSD2SI;
|
|
extern const Internal::SimdImpl_DestRegStrict<0xf3,0x2c,xRegister32, xRegisterSSE,u32> xCVTTSS2SI;
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
extern const Internal::SimdImpl_Shift<0xf0, 6> xPSLL;
|
|
extern const Internal::SimdImpl_Shift<0xd0, 2> xPSRL;
|
|
extern const Internal::SimdImpl_ShiftWithoutQ<0xe0, 4> xPSRA;
|
|
|
|
extern const Internal::SimdImpl_AddSub<0xdc, 0xd4> xPADD;
|
|
extern const Internal::SimdImpl_AddSub<0xd8, 0xfb> xPSUB;
|
|
extern const Internal::SimdImpl_PMinMax<0xde,0x3c> xPMAX;
|
|
extern const Internal::SimdImpl_PMinMax<0xda,0x38> xPMIN;
|
|
|
|
extern const Internal::SimdImpl_PMul xPMUL;
|
|
extern const Internal::SimdImpl_PCompare xPCMP;
|
|
extern const Internal::SimdImpl_PShuffle xPSHUF;
|
|
extern const Internal::SimdImpl_PUnpack xPUNPCK;
|
|
extern const Internal::SimdImpl_Unpack xUNPCK;
|
|
extern const Internal::SimdImpl_Pack xPACK;
|
|
|
|
extern const Internal::SimdImpl_PAbsolute xPABS;
|
|
extern const Internal::SimdImpl_PSign xPSIGN;
|
|
extern const Internal::SimdImpl_PInsert xPINSR;
|
|
extern const Internal::SimdImpl_PExtract xPEXTR;
|
|
extern const Internal::SimdImpl_PMultAdd xPMADD;
|
|
extern const Internal::SimdImpl_HorizAdd xHADD;
|
|
|
|
extern const Internal::SimdImpl_Blend xBLEND;
|
|
extern const Internal::SimdImpl_DotProduct xDP;
|
|
extern const Internal::SimdImpl_Round xROUND;
|
|
|
|
extern const Internal::SimdImpl_PMove<true> xPMOVSX;
|
|
extern const Internal::SimdImpl_PMove<false> xPMOVZX;
|
|
|
|
}
|
|
|