diff options
86 files changed, 14508 insertions, 550 deletions
diff --git a/compiler/cgbase.pas b/compiler/cgbase.pas index b7afff2e82..65dc75cae6 100644 --- a/compiler/cgbase.pas +++ b/compiler/cgbase.pas @@ -145,8 +145,8 @@ interface OS_F32,OS_F64,OS_F80,OS_C64,OS_F128, { multi-media sizes: split in byte, word, dword, ... } { entities, then the signed counterparts } - OS_M8,OS_M16,OS_M32,OS_M64,OS_M128, - OS_MS8,OS_MS16,OS_MS32,OS_MS64,OS_MS128); + OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M256, + OS_MS8,OS_MS16,OS_MS32,OS_MS64,OS_MS128,OS_MS256 ); { Register types } TRegisterType = ( @@ -174,7 +174,10 @@ interface R_SUBFQ, { = 8; Float that allocates 4 FPU registers } R_SUBMMS, { = 9; single scalar in multi media register } R_SUBMMD, { = 10; double scalar in multi media register } - R_SUBMMWHOLE { = 11; complete MM register, size depends on CPU } + R_SUBMMWHOLE, { = 11; complete MM register, size depends on CPU } + { For Intel X86 AVX-Register } + R_SUBMMX, { = 12; 128 BITS } + R_SUBMMY { = 13; 256 BITS } ); TSubRegisterSet = set of TSubRegister; @@ -272,7 +275,7 @@ interface { floating point values } 4,8,10,8,16, { multimedia values } - 1,2,4,8,16,1,2,4,8,16); + 1,2,4,8,16,32,1,2,4,8,16,32); tfloat2tcgsize: array[tfloattype] of tcgsize = (OS_F32,OS_F64,OS_F80,OS_F80,OS_C64,OS_C64,OS_F128); @@ -300,8 +303,8 @@ interface tcgsize2unsigned : array[tcgsize] of tcgsize = (OS_NO, OS_8,OS_16,OS_32,OS_64,OS_128,OS_8,OS_16,OS_32,OS_64,OS_128, OS_F32,OS_F64,OS_F80,OS_C64,OS_F128, - OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M8,OS_M16,OS_M32, - OS_M64,OS_M128); + OS_M8,OS_M16,OS_M32,OS_M64,OS_M128,OS_M256,OS_M8,OS_M16,OS_M32, + OS_M64,OS_M128,OS_M256); tcgloc2str : array[TCGLoc] of string[12] = ( 'LOC_INVALID', diff --git a/compiler/i386/cpubase.inc b/compiler/i386/cpubase.inc index 6efc218f1c..349a1e8d5c 100644 --- a/compiler/i386/cpubase.inc +++ b/compiler/i386/cpubase.inc @@ -34,7 +34,8 @@ S_MD, S_NEAR,S_FAR,S_SHORT, S_T, - S_XMM + S_XMM, + S_YMM ); diff --git a/compiler/i386/daopt386.pas b/compiler/i386/daopt386.pas index bdcaea11a2..82e45daeb6 100644 --- a/compiler/i386/daopt386.pas +++ b/compiler/i386/daopt386.pas @@ -58,6 +58,7 @@ const OS_M32, OS_ADDR,OS_NO,OS_NO, OS_NO, + OS_NO, OS_NO); diff --git a/compiler/i386/i386att.inc b/compiler/i386/i386att.inc index a591dad220..14ca3fbc0b 100644 --- a/compiler/i386/i386att.inc +++ b/compiler/i386/i386att.inc @@ -684,5 +684,264 @@ 'aeskeygenassist', 'stosq', 'lodsq', -'cmpsq' +'cmpsq', +'vaddpd', +'vaddps', +'vaddsd', +'vaddss', +'vaddsubpd', +'vaddsubps', +'vaesdec', +'vaesdeclast', +'vaesenc', +'vaesenclast', +'vaesimc', +'vaeskeygenassist', +'vandnpd', +'vandnps', +'vandpd', +'vandps', +'vblendpd', +'vblendps', +'vblendvpd', +'vblendvps', +'vbroadcastf128', +'vbroadcastsd', +'vbroadcastss', +'vcmppd', +'vcmpps', +'vcmpsd', +'vcmpss', +'vcomisd', +'vcomiss', +'vcvtdq2pd', +'vcvtdq2ps', +'vcvtpd2dq', +'vcvtpd2ps', +'vcvtps2dq', +'vcvtps2pd', +'vcvtsd2si', +'vcvtsd2ss', +'vcvtsi2sd', +'vcvtsi2ss', +'vcvtss2sd', +'vcvtss2si', +'vcvttpd2dq', +'vcvttps2dq', +'vcvttsd2si', +'vcvttss2si', +'vdivpd', +'vdivps', +'vdivsd', +'vdivss', +'vdppd', +'vdpps', +'vextractf128', +'vextractps', +'vhaddpd', +'vhaddps', +'vhsubpd', +'vhsubps', +'vinsertf128', +'vinsertps', +'vlddqu', +'vldmxcsr', +'vmaskmovdqu', +'vmaskmovpd', +'vmaskmovps', +'vmaxpd', +'vmaxps', +'vmaxsd', +'vmaxss', +'vminpd', +'vminps', +'vminsd', +'vminss', +'vmovapd', +'vmovaps', +'vmovd', +'vmovddup', +'vmovdqa', +'vmovdqu', +'vmovhlps', +'vmovhpd', +'vmovhps', +'vmovlhps', +'vmovlpd', +'vmovlps', +'vmovmskpd', +'vmovmskps', +'vmovntdq', +'vmovntdqa', +'vmovntpd', +'vmovntps', +'vmovq', +'vmovsd', +'vmovshdup', +'vmovsldup', +'vmovss', +'vmovupd', +'vmovups', +'vmpsadbw', +'vmulpd', +'vmulps', +'vmulsd', +'vmulss', +'vorpd', +'vorps', +'vpabsb', +'vpabsd', +'vpabsw', +'vpackssdw', +'vpacksswb', +'vpackusdw', +'vpackuswb', +'vpaddb', +'vpaddd', +'vpaddq', +'vpaddsb', +'vpaddsw', +'vpaddusb', +'vpaddusw', +'vpaddw', +'vpalignr', +'vpand', +'vpandn', +'vpavgb', +'vpavgw', +'vpblendvb', +'vpblendw', +'vpclmulqdq', +'vpcmpeqb', +'vpcmpeqd', +'vpcmpeqq', +'vpcmpeqw', +'vpcmpestri', +'vpcmpestrm', +'vpcmpgtb', +'vpcmpgtd', +'vpcmpgtq', +'vpcmpgtw', +'vpcmpistri', +'vpcmpistrm', +'vperm2f128', +'vpermilpd', +'vpermilps', +'vpextrb', +'vpextrd', +'vpextrq', +'vpextrw', +'vphaddd', +'vphaddsw', +'vphaddw', +'vphminposuw', +'vphsubd', +'vphsubsw', +'vphsubw', +'vpinsrb', +'vpinsrd', +'vpinsrq', +'vpinsrw', +'vpmaddubsw', +'vpmaddwd', +'vpmaxsb', +'vpmaxsd', +'vpmaxsw', +'vpmaxub', +'vpmaxud', +'vpmaxuw', +'vpminsb', +'vpminsd', +'vpminsw', +'vpminub', +'vpminud', +'vpminuw', +'vpmovmskb', +'vpmovsxbd', +'vpmovsxbq', +'vpmovsxbw', +'vpmovsxdq', +'vpmovsxwd', +'vpmovsxwq', +'vpmovzxbd', +'vpmovzxbq', +'vpmovzxbw', +'vpmovzxdq', +'vpmovzxwd', +'vpmovzxwq', +'vpmuldq', +'vpmulhrsw', +'vpmulhuw', +'vpmulhw', +'vpmulld', +'vpmullw', +'vpmuludq', +'vpor', +'vpsadbw', +'vpshufb', +'vpshufd', +'vpshufhw', +'vpshuflw', +'vpsignb', +'vpsignd', +'vpsignw', +'vpslld', +'vpslldq', +'vpsllq', +'vpsllw', +'vpsrad', +'vpsraw', +'vpsrld', +'vpsrldq', +'vpsrlq', +'vpsrlw', +'vpsubb', +'vpsubd', +'vpsubq', +'vpsubsb', +'vpsubsw', +'vpsubusb', +'vpsubusw', +'vpsubw', +'vptest', +'vpunpckhbw', +'vpunpckhdq', +'vpunpckhqdq', +'vpunpckhwd', +'vpunpcklbw', +'vpunpckldq', +'vpunpcklqdq', +'vpunpcklwd', +'vpxor', +'vrcpps', +'vrcpss', +'vroundpd', +'vroundps', +'vroundsd', +'vroundss', +'vrsqrtps', +'vrsqrtss', +'vshufpd', +'vshufps', +'vsqrtpd', +'vsqrtps', +'vsqrtsd', +'vsqrtss', +'vstmxcsr', +'vsubpd', +'vsubps', +'vsubsd', +'vsubss', +'vtestpd', +'vtestps', +'vucomisd', +'vucomiss', +'vunpckhpd', +'vunpckhps', +'vunpcklpd', +'vunpcklps', +'vxorpd', +'vxorps', +'vzeroall', +'vzeroupper' ); diff --git a/compiler/i386/i386atts.inc b/compiler/i386/i386atts.inc index 31bc9cd421..2f06270fe3 100644 --- a/compiler/i386/i386atts.inc +++ b/compiler/i386/i386atts.inc @@ -417,7 +417,7 @@ attsufNONE, attsufNONE, attsufNONE, attsufNONE, -attsufINT, +attsufMM, attsufINT, attsufNONE, attsufINT, @@ -534,7 +534,7 @@ attsufNONE, attsufNONE, attsufINT, attsufNONE, -attsufINT, +attsufMM, attsufNONE, attsufNONE, attsufNONE, @@ -684,5 +684,264 @@ attsufNONE, attsufNONE, attsufNONE, attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufMM, +attsufMM, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufMM, +attsufMM, +attsufNONE, +attsufNONE, +attsufMM, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, attsufNONE ); diff --git a/compiler/i386/i386int.inc b/compiler/i386/i386int.inc index b6cc4caa78..3a3f4b4631 100644 --- a/compiler/i386/i386int.inc +++ b/compiler/i386/i386int.inc @@ -684,5 +684,264 @@ 'aeskeygenassist', 'stosq', 'lodsq', -'cmpsq' +'cmpsq', +'vaddpd', +'vaddps', +'vaddsd', +'vaddss', +'vaddsubpd', +'vaddsubps', +'vaesdec', +'vaesdeclast', +'vaesenc', +'vaesenclast', +'vaesimc', +'vaeskeygenassist', +'vandnpd', +'vandnps', +'vandpd', +'vandps', +'vblendpd', +'vblendps', +'vblendvpd', +'vblendvps', +'vbroadcastf128', +'vbroadcastsd', +'vbroadcastss', +'vcmppd', +'vcmpps', +'vcmpsd', +'vcmpss', +'vcomisd', +'vcomiss', +'vcvtdq2pd', +'vcvtdq2ps', +'vcvtpd2dq', +'vcvtpd2ps', +'vcvtps2dq', +'vcvtps2pd', +'vcvtsd2si', +'vcvtsd2ss', +'vcvtsi2sd', +'vcvtsi2ss', +'vcvtss2sd', +'vcvtss2si', +'vcvttpd2dq', +'vcvttps2dq', +'vcvttsd2si', +'vcvttss2si', +'vdivpd', +'vdivps', +'vdivsd', +'vdivss', +'vdppd', +'vdpps', +'vextractf128', +'vextractps', +'vhaddpd', +'vhaddps', +'vhsubpd', +'vhsubps', +'vinsertf128', +'vinsertps', +'vlddqu', +'vldmxcsr', +'vmaskmovdqu', +'vmaskmovpd', +'vmaskmovps', +'vmaxpd', +'vmaxps', +'vmaxsd', +'vmaxss', +'vminpd', +'vminps', +'vminsd', +'vminss', +'vmovapd', +'vmovaps', +'vmovd', +'vmovddup', +'vmovdqa', +'vmovdqu', +'vmovhlps', +'vmovhpd', +'vmovhps', +'vmovlhps', +'vmovlpd', +'vmovlps', +'vmovmskpd', +'vmovmskps', +'vmovntdq', +'vmovntdqa', +'vmovntpd', +'vmovntps', +'vmovq', +'vmovsd', +'vmovshdup', +'vmovsldup', +'vmovss', +'vmovupd', +'vmovups', +'vmpsadbw', +'vmulpd', +'vmulps', +'vmulsd', +'vmulss', +'vorpd', +'vorps', +'vpabsb', +'vpabsd', +'vpabsw', +'vpackssdw', +'vpacksswb', +'vpackusdw', +'vpackuswb', +'vpaddb', +'vpaddd', +'vpaddq', +'vpaddsb', +'vpaddsw', +'vpaddusb', +'vpaddusw', +'vpaddw', +'vpalignr', +'vpand', +'vpandn', +'vpavgb', +'vpavgw', +'vpblendvb', +'vpblendw', +'vpclmulqdq', +'vpcmpeqb', +'vpcmpeqd', +'vpcmpeqq', +'vpcmpeqw', +'vpcmpestri', +'vpcmpestrm', +'vpcmpgtb', +'vpcmpgtd', +'vpcmpgtq', +'vpcmpgtw', +'vpcmpistri', +'vpcmpistrm', +'vperm2f128', +'vpermilpd', +'vpermilps', +'vpextrb', +'vpextrd', +'vpextrq', +'vpextrw', +'vphaddd', +'vphaddsw', +'vphaddw', +'vphminposuw', +'vphsubd', +'vphsubsw', +'vphsubw', +'vpinsrb', +'vpinsrd', +'vpinsrq', +'vpinsrw', +'vpmaddubsw', +'vpmaddwd', +'vpmaxsb', +'vpmaxsd', +'vpmaxsw', +'vpmaxub', +'vpmaxud', +'vpmaxuw', +'vpminsb', +'vpminsd', +'vpminsw', +'vpminub', +'vpminud', +'vpminuw', +'vpmovmskb', +'vpmovsxbd', +'vpmovsxbq', +'vpmovsxbw', +'vpmovsxdq', +'vpmovsxwd', +'vpmovsxwq', +'vpmovzxbd', +'vpmovzxbq', +'vpmovzxbw', +'vpmovzxdq', +'vpmovzxwd', +'vpmovzxwq', +'vpmuldq', +'vpmulhrsw', +'vpmulhuw', +'vpmulhw', +'vpmulld', +'vpmullw', +'vpmuludq', +'vpor', +'vpsadbw', +'vpshufb', +'vpshufd', +'vpshufhw', +'vpshuflw', +'vpsignb', +'vpsignd', +'vpsignw', +'vpslld', +'vpslldq', +'vpsllq', +'vpsllw', +'vpsrad', +'vpsraw', +'vpsrld', +'vpsrldq', +'vpsrlq', +'vpsrlw', +'vpsubb', +'vpsubd', +'vpsubq', +'vpsubsb', +'vpsubsw', +'vpsubusb', +'vpsubusw', +'vpsubw', +'vptest', +'vpunpckhbw', +'vpunpckhdq', +'vpunpckhqdq', +'vpunpckhwd', +'vpunpcklbw', +'vpunpckldq', +'vpunpcklqdq', +'vpunpcklwd', +'vpxor', +'vrcpps', +'vrcpss', +'vroundpd', +'vroundps', +'vroundsd', +'vroundss', +'vrsqrtps', +'vrsqrtss', +'vshufpd', +'vshufps', +'vsqrtpd', +'vsqrtps', +'vsqrtsd', +'vsqrtss', +'vstmxcsr', +'vsubpd', +'vsubps', +'vsubsd', +'vsubss', +'vtestpd', +'vtestps', +'vucomisd', +'vucomiss', +'vunpckhpd', +'vunpckhps', +'vunpcklpd', +'vunpcklps', +'vxorpd', +'vxorps', +'vzeroall', +'vzeroupper' ); diff --git a/compiler/i386/i386nop.inc b/compiler/i386/i386nop.inc index 148db9c7eb..2c78c83758 100644 --- a/compiler/i386/i386nop.inc +++ b/compiler/i386/i386nop.inc @@ -1,2 +1,2 @@ { don't edit, this file is generated from x86ins.dat } -1208; +1652; diff --git a/compiler/i386/i386op.inc b/compiler/i386/i386op.inc index 4070734e54..fbbb16b8c6 100644 --- a/compiler/i386/i386op.inc +++ b/compiler/i386/i386op.inc @@ -684,5 +684,264 @@ A_AESIMC, A_AESKEYGENASSIST, A_STOSQ, A_LODSQ, -A_CMPSQ +A_CMPSQ, +A_VADDPD, +A_VADDPS, +A_VADDSD, +A_VADDSS, +A_VADDSUBPD, +A_VADDSUBPS, +A_VAESDEC, +A_VAESDECLAST, +A_VAESENC, +A_VAESENCLAST, +A_VAESIMC, +A_VAESKEYGENASSIST, +A_VANDNPD, +A_VANDNPS, +A_VANDPD, +A_VANDPS, +A_VBLENDPD, +A_VBLENDPS, +A_VBLENDVPD, +A_VBLENDVPS, +A_VBROADCASTF128, +A_VBROADCASTSD, +A_VBROADCASTSS, +A_VCMPPD, +A_VCMPPS, +A_VCMPSD, +A_VCMPSS, +A_VCOMISD, +A_VCOMISS, +A_VCVTDQ2PD, +A_VCVTDQ2PS, +A_VCVTPD2DQ, +A_VCVTPD2PS, +A_VCVTPS2DQ, +A_VCVTPS2PD, +A_VCVTSD2SI, +A_VCVTSD2SS, +A_VCVTSI2SD, +A_VCVTSI2SS, +A_VCVTSS2SD, +A_VCVTSS2SI, +A_VCVTTPD2DQ, +A_VCVTTPS2DQ, +A_VCVTTSD2SI, +A_VCVTTSS2SI, +A_VDIVPD, +A_VDIVPS, +A_VDIVSD, +A_VDIVSS, +A_VDPPD, +A_VDPPS, +A_VEXTRACTF128, +A_VEXTRACTPS, +A_VHADDPD, +A_VHADDPS, +A_VHSUBPD, +A_VHSUBPS, +A_VINSERTF128, +A_VINSERTPS, +A_VLDDQU, +A_VLDMXCSR, +A_VMASKMOVDQU, +A_VMASKMOVPD, +A_VMASKMOVPS, +A_VMAXPD, +A_VMAXPS, +A_VMAXSD, +A_VMAXSS, +A_VMINPD, +A_VMINPS, +A_VMINSD, +A_VMINSS, +A_VMOVAPD, +A_VMOVAPS, +A_VMOVD, +A_VMOVDDUP, +A_VMOVDQA, +A_VMOVDQU, +A_VMOVHLPS, +A_VMOVHPD, +A_VMOVHPS, +A_VMOVLHPS, +A_VMOVLPD, +A_VMOVLPS, +A_VMOVMSKPD, +A_VMOVMSKPS, +A_VMOVNTDQ, +A_VMOVNTDQA, +A_VMOVNTPD, +A_VMOVNTPS, +A_VMOVQ, +A_VMOVSD, +A_VMOVSHDUP, +A_VMOVSLDUP, +A_VMOVSS, +A_VMOVUPD, +A_VMOVUPS, +A_VMPSADBW, +A_VMULPD, +A_VMULPS, +A_VMULSD, +A_VMULSS, +A_VORPD, +A_VORPS, +A_VPABSB, +A_VPABSD, +A_VPABSW, +A_VPACKSSDW, +A_VPACKSSWB, +A_VPACKUSDW, +A_VPACKUSWB, +A_VPADDB, +A_VPADDD, +A_VPADDQ, +A_VPADDSB, +A_VPADDSW, +A_VPADDUSB, +A_VPADDUSW, +A_VPADDW, +A_VPALIGNR, +A_VPAND, +A_VPANDN, +A_VPAVGB, +A_VPAVGW, +A_VPBLENDVB, +A_VPBLENDW, +A_VPCLMULQDQ, +A_VPCMPEQB, +A_VPCMPEQD, +A_VPCMPEQQ, +A_VPCMPEQW, +A_VPCMPESTRI, +A_VPCMPESTRM, +A_VPCMPGTB, +A_VPCMPGTD, +A_VPCMPGTQ, +A_VPCMPGTW, +A_VPCMPISTRI, +A_VPCMPISTRM, +A_VPERM2F128, +A_VPERMILPD, +A_VPERMILPS, +A_VPEXTRB, +A_VPEXTRD, +A_VPEXTRQ, +A_VPEXTRW, +A_VPHADDD, +A_VPHADDSW, +A_VPHADDW, +A_VPHMINPOSUW, +A_VPHSUBD, +A_VPHSUBSW, +A_VPHSUBW, +A_VPINSRB, +A_VPINSRD, +A_VPINSRQ, +A_VPINSRW, +A_VPMADDUBSW, +A_VPMADDWD, +A_VPMAXSB, +A_VPMAXSD, +A_VPMAXSW, +A_VPMAXUB, +A_VPMAXUD, +A_VPMAXUW, +A_VPMINSB, +A_VPMINSD, +A_VPMINSW, +A_VPMINUB, +A_VPMINUD, +A_VPMINUW, +A_VPMOVMSKB, +A_VPMOVSXBD, +A_VPMOVSXBQ, +A_VPMOVSXBW, +A_VPMOVSXDQ, +A_VPMOVSXWD, +A_VPMOVSXWQ, +A_VPMOVZXBD, +A_VPMOVZXBQ, +A_VPMOVZXBW, +A_VPMOVZXDQ, +A_VPMOVZXWD, +A_VPMOVZXWQ, +A_VPMULDQ, +A_VPMULHRSW, +A_VPMULHUW, +A_VPMULHW, +A_VPMULLD, +A_VPMULLW, +A_VPMULUDQ, +A_VPOR, +A_VPSADBW, +A_VPSHUFB, +A_VPSHUFD, +A_VPSHUFHW, +A_VPSHUFLW, +A_VPSIGNB, +A_VPSIGND, +A_VPSIGNW, +A_VPSLLD, +A_VPSLLDQ, +A_VPSLLQ, +A_VPSLLW, +A_VPSRAD, +A_VPSRAW, +A_VPSRLD, +A_VPSRLDQ, +A_VPSRLQ, +A_VPSRLW, +A_VPSUBB, +A_VPSUBD, +A_VPSUBQ, +A_VPSUBSB, +A_VPSUBSW, +A_VPSUBUSB, +A_VPSUBUSW, +A_VPSUBW, +A_VPTEST, +A_VPUNPCKHBW, +A_VPUNPCKHDQ, +A_VPUNPCKHQDQ, +A_VPUNPCKHWD, +A_VPUNPCKLBW, +A_VPUNPCKLDQ, +A_VPUNPCKLQDQ, +A_VPUNPCKLWD, +A_VPXOR, +A_VRCPPS, +A_VRCPSS, +A_VROUNDPD, +A_VROUNDPS, +A_VROUNDSD, +A_VROUNDSS, +A_VRSQRTPS, +A_VRSQRTSS, +A_VSHUFPD, +A_VSHUFPS, +A_VSQRTPD, +A_VSQRTPS, +A_VSQRTSD, +A_VSQRTSS, +A_VSTMXCSR, +A_VSUBPD, +A_VSUBPS, +A_VSUBSD, +A_VSUBSS, +A_VTESTPD, +A_VTESTPS, +A_VUCOMISD, +A_VUCOMISS, +A_VUNPCKHPD, +A_VUNPCKHPS, +A_VUNPCKLPD, +A_VUNPCKLPS, +A_VXORPD, +A_VXORPS, +A_VZEROALL, +A_VZEROUPPER ); diff --git a/compiler/i386/i386prop.inc b/compiler/i386/i386prop.inc index 4a8f2f7fa4..e57a923f65 100644 --- a/compiler/i386/i386prop.inc +++ b/compiler/i386/i386prop.inc @@ -684,5 +684,264 @@ (Ch: (Ch_All, Ch_None, Ch_None)), (Ch: (Ch_RRAX, Ch_WMemEDI, Ch_RWRDI)), (Ch: (Ch_WRAX, Ch_RWRSI, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), (Ch: (Ch_All, Ch_None, Ch_None)) ); diff --git a/compiler/i386/i386tab.inc b/compiler/i386/i386tab.inc index 0c427a24a4..a170207709 100644 --- a/compiler/i386/i386tab.inc +++ b/compiler/i386/i386tab.inc @@ -4042,7 +4042,7 @@ ( opcode : A_POR; ops : 2; - optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); code : #241#2#15#235#72; flags : if_willamette or if_sse2 or if_sm ), @@ -6142,21 +6142,14 @@ ( opcode : A_CVTPI2PS; ops : 2; - optypes : (ot_xmmreg,ot_memory,ot_none,ot_none); - code : #217#2#15#42#72; - flags : if_katmai or if_sse or if_mmx - ), - ( - opcode : A_CVTPI2PS; - ops : 2; - optypes : (ot_xmmreg,ot_mmxreg,ot_none,ot_none); + optypes : (ot_xmmreg,ot_mmxrm,ot_none,ot_none); code : #217#2#15#42#72; flags : if_katmai or if_sse or if_mmx ), ( opcode : A_CVTPS2PI; ops : 2; - optypes : (ot_mmxreg,ot_memory,ot_none,ot_none); + optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none); code : #217#2#15#45#72; flags : if_katmai or if_sse or if_mmx ), @@ -6170,21 +6163,14 @@ ( opcode : A_CVTSI2SS; ops : 2; - optypes : (ot_xmmreg,ot_memory,ot_none,ot_none); - code : #219#209#2#15#42#72; - flags : if_katmai or if_sse - ), - ( - opcode : A_CVTSI2SS; - ops : 2; - optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none); + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none); code : #219#209#2#15#42#72; flags : if_katmai or if_sse ), ( opcode : A_CVTSS2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none); code : #219#208#2#15#45#72; flags : if_katmai or if_sse ), @@ -6198,7 +6184,7 @@ ( opcode : A_CVTTPS2PI; ops : 2; - optypes : (ot_mmxreg,ot_memory,ot_none,ot_none); + optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none); code : #217#2#15#44#72; flags : if_katmai or if_sse or if_mmx ), @@ -6212,7 +6198,7 @@ ( opcode : A_CVTTSS2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none); code : #219#208#2#15#44#72; flags : if_katmai or if_sse ), @@ -7143,7 +7129,14 @@ ( opcode : A_CVTDQ2PD; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #219#2#15#230#72; + flags : if_willamette or if_sse2 + ), + ( + opcode : A_CVTDQ2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); code : #219#2#15#230#72; flags : if_willamette or if_sse2 ), @@ -7192,63 +7185,70 @@ ( opcode : A_CVTPS2PD; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #2#15#90#72; + flags : if_willamette or if_sse2 + ), + ( + opcode : A_CVTPS2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); code : #2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSD2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_xmmreg,ot_none,ot_none); - code : #220#208#2#15#45#72; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #220#2#15#45#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSD2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); - code : #220#208#2#15#45#72; + optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#2#15#45#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSD2SS; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); code : #220#2#15#90#72; flags : if_willamette or if_sse2 ), ( - opcode : A_CVTSI2SD; + opcode : A_CVTSD2SS; ops : 2; - optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none); - code : #220#209#2#15#42#72; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSI2SD; ops : 2; - optypes : (ot_xmmreg,ot_memory,ot_none,ot_none); - code : #220#209#2#15#42#72; + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none); + code : #220#2#15#42#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSS2SD; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); code : #219#2#15#90#72; flags : if_willamette or if_sse2 ), ( - opcode : A_CVTTPD2PI; + opcode : A_CVTSS2SD; ops : 2; - optypes : (ot_mmxreg,ot_xmmreg,ot_none,ot_none); - code : #241#2#15#44#72; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTTPD2PI; ops : 2; - optypes : (ot_mmxreg,ot_memory,ot_none,ot_none); + optypes : (ot_mmxreg,ot_xmmrm,ot_none,ot_none); code : #241#2#15#44#72; flags : if_willamette or if_sse2 ), @@ -7276,7 +7276,7 @@ ( opcode : A_CVTTSD2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits64,ot_none,ot_none); code : #220#208#2#15#44#72; flags : if_willamette or if_sse2 ), @@ -8455,5 +8455,3113 @@ optypes : (ot_xmmreg,ot_xmmrm,ot_immediate,ot_none); code : #241#3#15#58#223#72#22; flags : if_sse4 or if_sb or if_ar2 + ), + ( + opcode : A_VADDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #220#242#244#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #220#242#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESDEC; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#222#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESDECLAST; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#223#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESENC; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#220#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESENCLAST; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#221#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESIMC; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#219#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESKEYGENASSIST; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#223#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#13#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#13#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#12#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#12#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg); + code : #241#242#250#1#75#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg); + code : #241#242#244#250#1#75#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg); + code : #241#242#250#1#74#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg); + code : #241#242#244#250#1#74#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTF128; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #241#242#244#249#1#26#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTSD; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#244#249#1#25#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTSS; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#244#249#1#24#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTSS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#24#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #242#244#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8); + code : #220#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #220#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8); + code : #219#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #219#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #219#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmreg,ot_none,ot_none); + code : #219#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #219#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #220#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none); + code : #220#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2PS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2PS; + ops : 2; + optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2DQ; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #242#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2PD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2PD; + ops : 2; + optypes : (ot_ymmreg,ot_xmmrm,ot_none,ot_none); + code : #242#244#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #220#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSI2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none); + code : #220#242#248#1#42#61#80; + flags : if_avx or if_sandybridge or if_sd + ), + ( + opcode : A_VCVTSI2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none); + code : #220#242#243#248#1#42#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSI2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none); + code : #219#242#248#1#42#61#80; + flags : if_avx or if_sandybridge or if_sd + ), + ( + opcode : A_VCVTSI2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none); + code : #219#242#243#248#1#42#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #219#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPS2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPS2DQ; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #220#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #219#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDPPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#65#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDPPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#64#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDPPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#64#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VEXTRACTF128; + ops : 3; + optypes : (ot_xmmrm,ot_ymmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#25#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VEXTRACTPS; + ops : 3; + optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#23#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #220#242#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #220#242#244#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #220#242#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #220#242#244#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VINSERTF128; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#24#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VINSERTPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8); + code : #241#242#250#1#33#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VINSERTPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #241#242#250#1#33#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VLDDQU; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #220#242#248#1#240#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VLDDQU; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits256,ot_none,ot_none); + code : #220#242#244#248#1#240#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VLDMXCSR; + ops : 1; + optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none); + code : #242#248#1#174#130; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVDQU; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#247#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none); + code : #241#242#244#249#1#47#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none); + code : #241#242#249#1#47#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none); + code : #241#242#244#249#1#45#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none); + code : #241#242#249#1#45#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none); + code : #241#242#244#249#1#46#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none); + code : #241#242#249#1#46#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none); + code : #241#242#244#249#1#44#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none); + code : #241#242#249#1#44#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVD; + ops : 2; + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none); + code : #241#242#248#1#110#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVD; + ops : 2; + optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#126#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDDUP; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #220#242#244#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDDUP; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDDUP; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #219#242#244#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHLPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #242#248#1#18#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPD; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#23#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #241#242#248#1#22#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #242#248#1#22#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPS; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#23#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLHPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #242#248#1#22#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPD; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#19#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #241#242#248#1#18#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPS; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#19#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #242#248#1#18#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTDQ; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#231#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTDQ; + ops : 2; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#231#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTDQA; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #241#242#249#1#42#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPD; + ops : 2; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPD; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPS; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPS; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVQ; + ops : 2; + optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #241#242#243#248#1#126#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVQ; + ops : 2; + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none); + code : #241#242#243#248#1#110#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#16#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#17#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSHDUP; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#22#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSHDUP; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#22#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSLDUP; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSLDUP; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#16#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #219#242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#17#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMPSADBW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#66#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VORPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#86#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VORPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#86#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VORPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#86#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPABSB; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#28#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPABSD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#30#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPABSW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#29#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKSSDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#107#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKSSWB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#99#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKUSDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#43#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKUSWB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#103#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#252#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#254#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#212#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#236#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#237#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDUSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#220#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDUSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#221#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#253#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPALIGNR; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#15#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPAND; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#219#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPANDN; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#223#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPAVGB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#224#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPAVGW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#227#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPBLENDVB; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg); + code : #241#242#250#1#76#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPBLENDW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#14#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCLMULQDQ; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#68#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#116#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#118#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#41#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#117#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPESTRI; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#97#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPESTRM; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#96#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#100#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#102#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#55#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#101#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPISTRI; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#99#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPISTRM; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#98#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERM2F128; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#6#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#249#1#13#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#5#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#5#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#13#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#249#1#12#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#4#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#4#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#12#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRB; + ops : 3; + optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#20#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRB; + ops : 3; + optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#20#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRB; + ops : 3; + optypes : (ot_memory or ot_bits8,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#20#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRD; + ops : 3; + optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#22#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRQ; + ops : 3; + optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#243#250#1#22#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#197#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#197#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#21#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#21#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_memory or ot_bits16,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#21#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHADDD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#2#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHADDSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#3#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHADDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#1#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHMINPOSUW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#65#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHSUBD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#6#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHSUBSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#7#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHSUBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#5#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRB; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8); + code : #241#242#250#1#32#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRB; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits8,ot_immediate or ot_bits8); + code : #241#242#250#1#32#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_immediate or ot_bits8); + code : #241#242#250#1#34#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRQ; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_immediate or ot_bits8); + code : #241#242#243#250#1#34#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8); + code : #241#242#248#1#196#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits16,ot_immediate or ot_bits8); + code : #241#242#248#1#196#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMADDUBSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#4#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMADDWD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#245#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#60#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#61#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#238#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXUB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#222#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXUD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#63#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXUW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#62#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#56#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#57#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#234#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINUB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#218#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINUD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#59#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINUW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#58#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVMSKB; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#215#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVMSKB; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#215#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#33#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#33#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none); + code : #241#242#249#1#34#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#34#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBW; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#32#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#32#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#37#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#37#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#35#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#35#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#36#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#36#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#49#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#49#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none); + code : #241#242#249#1#50#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#50#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBW; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#48#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#48#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#53#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#53#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#51#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#51#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#52#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#52#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#40#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULHRSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#11#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULHUW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#228#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULHW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#229#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#64#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#213#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULUDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#244#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPOR; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#235#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSADBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#246#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#0#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#112#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFHW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #219#242#248#1#112#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #220#242#248#1#112#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSIGNB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#8#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSIGND; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#10#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSIGNW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#9#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#114#60#142#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#242#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#143#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#243#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#142#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#113#60#142#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#241#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#114#60#140#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#226#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#113#60#140#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#225#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#114#60#138#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#210#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#139#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#138#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#211#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#113#60#138#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#209#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#248#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#250#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#251#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#232#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#233#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBUSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#216#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBUSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#217#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#249#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPTEST; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#249#1#23#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPTEST; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#23#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#104#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#106#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHQDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#109#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHWD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#105#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#96#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#98#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLQDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#108#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLWD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#97#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPXOR; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#239#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#83#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#83#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#83#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#83#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#9#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#9#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#8#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#8#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8); + code : #241#242#250#1#11#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #241#242#250#1#11#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8); + code : #241#242#250#1#10#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #241#242#250#1#10#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#82#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#82#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#82#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#82#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #242#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #242#244#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSTMXCSR; + ops : 1; + optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none); + code : #242#248#1#174#131; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#15#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#249#1#15#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#249#1#14#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#14#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VZEROALL; + ops : 0; + optypes : (ot_none,ot_none,ot_none,ot_none); + code : #242#244#248#1#119; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VZEROUPPER; + ops : 0; + optypes : (ot_none,ot_none,ot_none,ot_none); + code : #242#248#1#119; + flags : if_avx or if_sandybridge ) ); diff --git a/compiler/i386/r386ari.inc b/compiler/i386/r386ari.inc index 1bccc9846d..308a4e9366 100644 --- a/compiler/i386/r386ari.inc +++ b/compiler/i386/r386ari.inc @@ -71,4 +71,12 @@ 70, 71, 72, +73, +74, +75, +76, +77, +78, +79, +80, 0 diff --git a/compiler/i386/r386att.inc b/compiler/i386/r386att.inc index 2c3df1312c..a1ffa9a4e5 100644 --- a/compiler/i386/r386att.inc +++ b/compiler/i386/r386att.inc @@ -71,4 +71,12 @@ '%xmm4', '%xmm5', '%xmm6', -'%xmm7' +'%xmm7', +'%ymm0', +'%ymm1', +'%ymm2', +'%ymm3', +'%ymm4', +'%ymm5', +'%ymm6', +'%ymm7' diff --git a/compiler/i386/r386con.inc b/compiler/i386/r386con.inc index 287b8cc195..7490b4284b 100644 --- a/compiler/i386/r386con.inc +++ b/compiler/i386/r386con.inc @@ -64,11 +64,19 @@ NR_MM4 = tregister($03000004); NR_MM5 = tregister($03000005); NR_MM6 = tregister($03000006); NR_MM7 = tregister($03000007); -NR_XMM0 = tregister($04000000); -NR_XMM1 = tregister($04000001); -NR_XMM2 = tregister($04000002); -NR_XMM3 = tregister($04000003); -NR_XMM4 = tregister($04000004); -NR_XMM5 = tregister($04000005); -NR_XMM6 = tregister($04000006); -NR_XMM7 = tregister($04000007); +NR_XMM0 = tregister($040C0000); +NR_XMM1 = tregister($040C0001); +NR_XMM2 = tregister($040C0002); +NR_XMM3 = tregister($040C0003); +NR_XMM4 = tregister($040C0004); +NR_XMM5 = tregister($040C0005); +NR_XMM6 = tregister($040C0006); +NR_XMM7 = tregister($040C0007); +NR_YMM0 = tregister($040D0000); +NR_YMM1 = tregister($040D0001); +NR_YMM2 = tregister($040D0002); +NR_YMM3 = tregister($040D0003); +NR_YMM4 = tregister($040D0004); +NR_YMM5 = tregister($040D0005); +NR_YMM6 = tregister($040D0006); +NR_YMM7 = tregister($040D0007); diff --git a/compiler/i386/r386dwrf.inc b/compiler/i386/r386dwrf.inc index aeb8959984..89af30a5fb 100644 --- a/compiler/i386/r386dwrf.inc +++ b/compiler/i386/r386dwrf.inc @@ -71,4 +71,12 @@ 25, 26, 27, +28, +21, +22, +23, +24, +25, +26, +27, 28 diff --git a/compiler/i386/r386int.inc b/compiler/i386/r386int.inc index d505d5b41a..c1cc5aafe9 100644 --- a/compiler/i386/r386int.inc +++ b/compiler/i386/r386int.inc @@ -71,4 +71,12 @@ 'xmm4', 'xmm5', 'xmm6', -'xmm7' +'xmm7', +'ymm0', +'ymm1', +'ymm2', +'ymm3', +'ymm4', +'ymm5', +'ymm6', +'ymm7' diff --git a/compiler/i386/r386iri.inc b/compiler/i386/r386iri.inc index 9df079e88b..6dc9c21e2f 100644 --- a/compiler/i386/r386iri.inc +++ b/compiler/i386/r386iri.inc @@ -71,4 +71,12 @@ 69, 70, 71, -72 +72, +73, +74, +75, +76, +77, +78, +79, +80 diff --git a/compiler/i386/r386nasm.inc b/compiler/i386/r386nasm.inc index 6dfaf10e26..d8d754fa18 100644 --- a/compiler/i386/r386nasm.inc +++ b/compiler/i386/r386nasm.inc @@ -71,4 +71,12 @@ 'xmm4', 'xmm5', 'xmm6', -'xmm7' +'xmm7', +'ymm0', +'ymm1', +'ymm2', +'ymm3', +'ymm4', +'ymm5', +'ymm6', +'ymm7' diff --git a/compiler/i386/r386nor.inc b/compiler/i386/r386nor.inc index 6afcd4f51d..b4d5de5c03 100644 --- a/compiler/i386/r386nor.inc +++ b/compiler/i386/r386nor.inc @@ -1,2 +1,2 @@ { don't edit, this file is generated from x86reg.dat } -73 +81 diff --git a/compiler/i386/r386nri.inc b/compiler/i386/r386nri.inc index 9df079e88b..6dc9c21e2f 100644 --- a/compiler/i386/r386nri.inc +++ b/compiler/i386/r386nri.inc @@ -71,4 +71,12 @@ 69, 70, 71, -72 +72, +73, +74, +75, +76, +77, +78, +79, +80 diff --git a/compiler/i386/r386num.inc b/compiler/i386/r386num.inc index 2aa77d37ab..b64c292e6b 100644 --- a/compiler/i386/r386num.inc +++ b/compiler/i386/r386num.inc @@ -64,11 +64,19 @@ tregister($03000004), tregister($03000005), tregister($03000006), tregister($03000007), -tregister($04000000), -tregister($04000001), -tregister($04000002), -tregister($04000003), -tregister($04000004), -tregister($04000005), -tregister($04000006), -tregister($04000007) +tregister($040C0000), +tregister($040C0001), +tregister($040C0002), +tregister($040C0003), +tregister($040C0004), +tregister($040C0005), +tregister($040C0006), +tregister($040C0007), +tregister($040D0000), +tregister($040D0001), +tregister($040D0002), +tregister($040D0003), +tregister($040D0004), +tregister($040D0005), +tregister($040D0006), +tregister($040D0007) diff --git a/compiler/i386/r386op.inc b/compiler/i386/r386op.inc index 9a382981d4..f8d7f13e05 100644 --- a/compiler/i386/r386op.inc +++ b/compiler/i386/r386op.inc @@ -71,4 +71,12 @@ 4, 5, 6, +7, +0, +1, +2, +3, +4, +5, +6, 7 diff --git a/compiler/i386/r386ot.inc b/compiler/i386/r386ot.inc index 7d4900440b..663b499a3d 100644 --- a/compiler/i386/r386ot.inc +++ b/compiler/i386/r386ot.inc @@ -71,4 +71,12 @@ OT_XMMREG, OT_XMMREG, OT_XMMREG, OT_XMMREG, -OT_XMMREG +OT_XMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG diff --git a/compiler/i386/r386rni.inc b/compiler/i386/r386rni.inc index 73ded27e8b..8ba7ff2abe 100644 --- a/compiler/i386/r386rni.inc +++ b/compiler/i386/r386rni.inc @@ -49,6 +49,14 @@ 70, 71, 72, +73, +74, +75, +76, +77, +78, +79, +80, 26, 27, 28, diff --git a/compiler/i386/r386sri.inc b/compiler/i386/r386sri.inc index 9df079e88b..6dc9c21e2f 100644 --- a/compiler/i386/r386sri.inc +++ b/compiler/i386/r386sri.inc @@ -71,4 +71,12 @@ 69, 70, 71, -72 +72, +73, +74, +75, +76, +77, +78, +79, +80 diff --git a/compiler/i386/r386stab.inc b/compiler/i386/r386stab.inc index 9feadfb6e4..4011a98e70 100644 --- a/compiler/i386/r386stab.inc +++ b/compiler/i386/r386stab.inc @@ -71,4 +71,12 @@ 25, 26, 27, +28, +21, +22, +23, +24, +25, +26, +27, 28 diff --git a/compiler/i386/r386std.inc b/compiler/i386/r386std.inc index d505d5b41a..c1cc5aafe9 100644 --- a/compiler/i386/r386std.inc +++ b/compiler/i386/r386std.inc @@ -71,4 +71,12 @@ 'xmm4', 'xmm5', 'xmm6', -'xmm7' +'xmm7', +'ymm0', +'ymm1', +'ymm2', +'ymm3', +'ymm4', +'ymm5', +'ymm6', +'ymm7' diff --git a/compiler/m68k/cgcpu.pas b/compiler/m68k/cgcpu.pas index 8b6b83d0d5..3ce33d59eb 100644 --- a/compiler/m68k/cgcpu.pas +++ b/compiler/m68k/cgcpu.pas @@ -127,7 +127,8 @@ unit cgcpu; TCGSize2OpSize: Array[tcgsize] of topsize = (S_NO,S_B,S_W,S_L,S_L,S_NO,S_B,S_W,S_L,S_L,S_NO, S_FS,S_FD,S_FX,S_NO,S_NO, - S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO); + S_NO,S_NO,S_NO,S_NO,S_NO,S_NO, + S_NO,S_NO,S_NO,S_NO,S_NO,S_NO); procedure create_codegen; diff --git a/compiler/msg/errore.msg b/compiler/msg/errore.msg index dc0700f8e4..c888f504b7 100644 --- a/compiler/msg/errore.msg +++ b/compiler/msg/errore.msg @@ -2292,7 +2292,7 @@ cg_d_autoinlining=06055_DL_Auto inlining: $1 # # Assembler reader # -# 07120 is the last used one +# 07123 is the last used one # asmr_d_start_reading=07000_DL_Starting $1 styled assembler parsing % This informs you that an assembler block is being parsed @@ -2576,6 +2576,18 @@ asmr_e_no_gotpcrel_support=07118_E_The current target does not support GOTPCREL asmr_w_global_access_without_got=07119_W_Exported/global symbols should accessed via the GOT % Global symbols (symbols from the unit interface, or defined in a program % or library) should be accessed via the GOT when generating position-indepent code. +asmr_w_check_mem_operand_size=07120_W_Check size of memory operand "$1" +% The size of memory operand is possible invalid. This is +% probably an error in the assembler statement +asmr_w_check_mem_operand_size3=07121_W_Check size of memory operand "$1: memory-operand-size is $2 bits, but expected [$3 bits]" +% The size of memory operand is possible invalid. This is +% probably an error in the assembler statement +asmr_w_check_mem_operand_size_offset=07122_W_Check size of memory operand "$1: memory-operand-size is $2 bits, but expected [$3 bits + $4 byte offset]" +% The size of memory operand is possible invalid. This is +% probably an error in the assembler statement +asmr_w_check_mem_operand_negative_offset=07123_W_Check "$1: offset of memory operand is negative "$2 byte" +% The offset of memory operand is possible invalid. This is +% probably an error in the assembler statement # # Assembler/binary writers diff --git a/compiler/msgidx.inc b/compiler/msgidx.inc index a6a02fe2cf..3dadd935f8 100644 --- a/compiler/msgidx.inc +++ b/compiler/msgidx.inc @@ -748,6 +748,10 @@ const asmr_e_wrong_gotpcrel_intel_syntax=07117; asmr_e_no_gotpcrel_support=07118; asmr_w_global_access_without_got=07119; + asmr_w_check_mem_operand_size=07120; + asmr_w_check_mem_operand_size3=07121; + asmr_w_check_mem_operand_size_offset=07122; + asmr_w_check_mem_operand_negative_offset=07123; asmw_f_too_many_asm_files=08000; asmw_f_assembler_output_not_supported=08001; asmw_f_comp_not_supported=08002; @@ -950,9 +954,9 @@ const option_info=11024; option_help_pages=11025; - MsgTxtSize = 66543; + MsgTxtSize = 66864; MsgIdxMax : array[1..20] of longint=( - 26,92,323,120,87,56,120,26,202,63, + 26,92,323,120,87,56,124,26,202,63, 53,20,1,1,1,1,1,1,1,1 ); diff --git a/compiler/msgtxt.inc b/compiler/msgtxt.inc index 1a88365b72..19b3c0b7b3 100644 --- a/compiler/msgtxt.inc +++ b/compiler/msgtxt.inc @@ -1,7 +1,7 @@ {$ifdef Delphi} -const msgtxt : array[0..000277] of string[240]=( +const msgtxt : array[0..000278] of string[240]=( {$else Delphi} -const msgtxt : array[0..000277,1..240] of char=( +const msgtxt : array[0..000278,1..240] of char=( {$endif Delphi} '01000_T_Compiler: $1'#000+ '01001_D_Compiler OS: $1'#000+ @@ -906,258 +906,264 @@ const msgtxt : array[0..000277,1..240] of char=( ' a base or index register, and their offset must 0.'#000+ '07118_E_The current target does not support GOTPCREL relocations'#000+ '07119_W_Exported/global symbols should accessed via the GOT'#000+ + '07120_W_Check size of memory operand "$1"'#000+ + '07121_W_Check si','ze of memory operand "$1: memory-operand-size is $2 '+ + 'bits, but expected [$3 bits]"'#000+ + '07122_W_Check size of memory operand "$1: memory-operand-size is $2 bi'+ + 'ts, but expected [$3 bits + $4 byte offset]"'#000+ + '07123_W_Check "$1: offset of memory operand',' is negative "$2 byte"'#000+ '08000_F_Too many assembler files'#000+ - '08001_F_Selected assemble','r output not supported'#000+ + '08001_F_Selected assembler output not supported'#000+ '08002_F_Comp not supported'#000+ '08003_F_Direct not support for binary writers'#000+ '08004_E_Allocating of data is only allowed in bss section'#000+ - '08005_F_No binary writer selected'#000+ + '08005','_F_No binary writer selected'#000+ '08006_E_Asm: Opcode $1 not in table'#000+ - '08007_E_Asm: $1 ','invalid combination of opcode and operands'#000+ + '08007_E_Asm: $1 invalid combination of opcode and operands'#000+ '08008_E_Asm: 16 Bit references not supported'#000+ '08009_E_Asm: Invalid effective address'#000+ - '08010_E_Asm: Immediate or reference expected'#000+ + '08010_E_Asm: Immediate or refere','nce expected'#000+ '08011_E_Asm: $1 value exceeds bounds $2'#000+ - '08012_E_Asm: Short jump is o','ut of range $1'#000+ + '08012_E_Asm: Short jump is out of range $1'#000+ '08013_E_Asm: Undefined label $1'#000+ '08014_E_Asm: Comp type not supported for this target'#000+ '08015_E_Asm: Extended type not supported for this target'#000+ - '08016_E_Asm: Duplicate label $1'#000+ + '08','016_E_Asm: Duplicate label $1'#000+ '08017_E_Asm: Redefined label $1'#000+ - '08018_E_Asm: First ','defined here'#000+ + '08018_E_Asm: First defined here'#000+ '08019_E_Asm: Invalid register $1'#000+ '08020_E_Asm: 16 or 32 Bit references not supported'#000+ '08021_E_Asm: 64 Bit operands not supported'#000+ - '08022_E_Asm: AH,BH,CH or DH cannot be used in an instruction requiring'+ - ' REX prefix'#000+ - '08023_E_Missing .s','eh_endprologue directive'#000+ + '08022_E_Asm: AH,BH,','CH or DH cannot be used in an instruction requiri'+ + 'ng REX prefix'#000+ + '08023_E_Missing .seh_endprologue directive'#000+ '08024_E_Function prologue exceeds 255 bytes'#000+ '08025_E_.seh_handlerdata directive without preceding .seh_handler'#000+ - '09000_W_Source operating system redefined'#000+ + '09000_W_Source operating',' system redefined'#000+ '09001_I_Assembling (pipe) $1'#000+ - '09002_E_Can'#039't create assembler fil','e: $1'#000+ + '09002_E_Can'#039't create assembler file: $1'#000+ '09003_E_Can'#039't create object file: $1 (error code: $2)'#000+ '09004_E_Can'#039't create archive file: $1'#000+ - '09005_E_Assembler $1 not found, switching to external assembling'#000+ + '09005_E_Assembler $1 not found, switching to external assembl','ing'#000+ '09006_T_Using assembler: $1'#000+ '09007_E_Error while assembling exitcode $1'#000+ - '09008_','E_Can'#039't call the assembler, error $1 switching to external'+ - ' assembling'#000+ + '09008_E_Can'#039't call the assembler, error $1 switching to external a'+ + 'ssembling'#000+ '09009_I_Assembling $1'#000+ '09010_I_Assembling with smartlinking $1'#000+ - '09011_W_Object $1 not found, Linking may fail !'#000+ + '09011_W_Object $1 not found',', Linking may fail !'#000+ '09012_W_Library $1 not found, Linking may fail !'#000+ - '09013_E_Err','or while linking'#000+ + '09013_E_Error while linking'#000+ '09014_E_Can'#039't call the linker, switching to external linking'#000+ '09015_I_Linking $1'#000+ '09016_E_Util $1 not found, switching to external linking'#000+ - '09017_T_Using util $1'#000+ + '09017','_T_Using util $1'#000+ '09018_E_Creation of Executables not supported'#000+ - '09019_E_Creation o','f Dynamic/Shared Libraries not supported'#000+ + '09019_E_Creation of Dynamic/Shared Libraries not supported'#000+ '09020_I_Closing script $1'#000+ '09021_E_resource compiler "$1" not found, switching to external mode'#000+ - '09022_I_Compiling resource $1'#000+ + '09022_I_Compiling resou','rce $1'#000+ '09023_T_unit $1 can'#039't be statically linked, switching to smart lin'+ 'king'#000+ - '090','24_T_unit $1 can'#039't be smart linked, switching to static linki'+ - 'ng'#000+ + '09024_T_unit $1 can'#039't be smart linked, switching to static linking'+ + #000+ '09025_T_unit $1 can'#039't be shared linked, switching to static linkin'+ 'g'#000+ - '09026_E_unit $1 can'#039't be smart or static linked'#000+ + '09026_E_unit $1 can'#039't be sm','art or static linked'#000+ '09027_E_unit $1 can'#039't be shared or static linked'#000+ - '09028_D_Cal','ling resource compiler "$1" with "$2" as command line'#000+ + '09028_D_Calling resource compiler "$1" with "$2" as command line'#000+ '09029_E_Error while compiling resources'#000+ - '09030_E_Can'#039't call the resource compiler "$1", switching to extern'+ - 'al mode'#000+ + '09030_E_Can'#039't call the resource compiler "$1", switching to exter', + 'nal mode'#000+ '09031_E_Can'#039't open resource file "$1"'#000+ - '09032_E_Can'#039't write resource file ','"$1"'#000+ + '09032_E_Can'#039't write resource file "$1"'#000+ '09033_N_File "$1" not found for backquoted cat command'#000+ '09128_F_Can'#039't post process executable $1'#000+ '09129_F_Can'#039't open executable $1'#000+ - '09130_X_Size of Code: $1 bytes'#000+ + '09130_X_Size of Code: $1 ','bytes'#000+ '09131_X_Size of initialized data: $1 bytes'#000+ - '09132_X_Size of uninitialized da','ta: $1 bytes'#000+ + '09132_X_Size of uninitialized data: $1 bytes'#000+ '09133_X_Stack space reserved: $1 bytes'#000+ '09134_X_Stack space committed: $1 bytes'#000+ '09200_F_Executable image size is too big for $1 target.'#000+ - '09201_W_Object file "$1" contains 32-bit absolute relocation to symbol'+ - ' "$2".'#000+ - '10000_T_Unitsea','rch: $1'#000+ + '09201_W_Obj','ect file "$1" contains 32-bit absolute relocation to symb'+ + 'ol "$2".'#000+ + '10000_T_Unitsearch: $1'#000+ '10001_T_PPU Loading $1'#000+ '10002_U_PPU Name: $1'#000+ '10003_U_PPU Flags: $1'#000+ '10004_U_PPU Crc: $1'#000+ '10005_U_PPU Time: $1'#000+ '10006_U_PPU File too short'#000+ - '10007_U_PPU Invalid Header (no PPU at the begin)'#000+ + '10007_U_PPU Inval','id Header (no PPU at the begin)'#000+ '10008_U_PPU Invalid Version $1'#000+ - '10009_U_PPU is com','piled for another processor'#000+ + '10009_U_PPU is compiled for another processor'#000+ '10010_U_PPU is compiled for another target'#000+ '10011_U_PPU Source: $1'#000+ '10012_U_Writing $1'#000+ '10013_F_Can'#039't Write PPU-File'#000+ - '10014_F_Error reading PPU-File'#000+ + '10014_F_Error rea','ding PPU-File'#000+ '10015_F_unexpected end of PPU-File'#000+ - '10016_F_Invalid PPU-File entry: ','$1'#000+ + '10016_F_Invalid PPU-File entry: $1'#000+ '10017_F_PPU Dbx count problem'#000+ '10018_E_Illegal unit name: $1'#000+ '10019_F_Too much units'#000+ '10020_F_Circular unit reference between $1 and $2'#000+ - '10021_F_Can'#039't compile unit $1, no sources available'#000+ + '10021_F_Can'#039't compile u','nit $1, no sources available'#000+ '10022_F_Can'#039't find unit $1 used by $2'#000+ - '10023_W_Unit $','1 was not found but $2 exists'#000+ + '10023_W_Unit $1 was not found but $2 exists'#000+ '10024_F_Unit $1 searched but $2 found'#000+ '10025_W_Compiling the system unit requires the -Us switch'#000+ - '10026_F_There were $1 errors compiling module, stopping'#000+ + '10026_F_There were $1 errors comp','iling module, stopping'#000+ '10027_U_Load from $1 ($2) unit $3'#000+ - '10028_U_Recompiling $1, ','checksum changed for $2'#000+ + '10028_U_Recompiling $1, checksum changed for $2'#000+ '10029_U_Recompiling $1, source found only'#000+ '10030_U_Recompiling unit, static lib is older than ppufile'#000+ - '10031_U_Recompiling unit, shared lib is older than ppufile'#000+ - '10032_U_Recompiling unit, obj and asm are older than ppu','file'#000+ + '10031_U_Recompiling unit, shared l','ib is older than ppufile'#000+ + '10032_U_Recompiling unit, obj and asm are older than ppufile'#000+ '10033_U_Recompiling unit, obj is older than asm'#000+ '10034_U_Parsing interface of $1'#000+ '10035_U_Parsing implementation of $1'#000+ '10036_U_Second load for unit $1'#000+ - '10037_U_PPU Check file $1 time $2'#000+ - '10040_W_Can'#039't recompile unit $1, but found modifed i','nclude files'+ - #000+ + '10037','_U_PPU Check file $1 time $2'#000+ + '10040_W_Can'#039't recompile unit $1, but found modifed include files'#000+ '10041_U_File $1 is newer than the one used for creating PPU file $2'#000+ '10042_U_Trying to use a unit which was compiled with a different FPU m'+ 'ode'#000+ - '10043_U_Loading interface units from $1'#000+ - '10044_U_Loading implementation units from $1'#000, + '1004','3_U_Loading interface units from $1'#000+ + '10044_U_Loading implementation units from $1'#000+ '10045_U_Interface CRC changed for unit $1'#000+ '10046_U_Implementation CRC changed for unit $1'#000+ '10047_U_Finished compiling unit $1'#000+ - '10048_U_Adding dependency: $1 depends on $2'#000+ + '10048_U_Adding dependency: $1 depen','ds on $2'#000+ '10049_U_No reload, is caller: $1'#000+ - '10050_U_No reload, already in second co','mpile: $1'#000+ + '10050_U_No reload, already in second compile: $1'#000+ '10051_U_Flag for reload: $1'#000+ '10052_U_Forced reloading'#000+ '10053_U_Previous state of $1: $2'#000+ '10054_U_Already compiling $1, setting second compile'#000+ - '10055_U_Loading unit $1'#000+ + '10055_U_Lo','ading unit $1'#000+ '10056_U_Finished loading unit $1'#000+ '10057_U_Registering new unit $1'#000+ - '10','058_U_Re-resolving unit $1'#000+ + '10058_U_Re-resolving unit $1'#000+ '10059_U_Skipping re-resolving unit $1, still loading used units'#000+ '10060_U_Unloading resource unit $1 (not needed)'#000+ - '10061_E_Unit $1 was compiled using a different whole program optimizat'+ - 'ion feedback input ($2, $3); re','compile it without wpo or use the sam'+ + '10061_E_Unit $1 was ','compiled using a different whole program optimiz'+ + 'ation feedback input ($2, $3); recompile it without wpo or use the sam'+ 'e wpo feedback input file for this compilation invocation'#000+ - '10062_U_Indirect interface (objects/classes) CRC changed for unit $1'#000+ + '10062_U_Indirect interface (objects/classes) CRC changed for uni','t $1'+ + #000+ '11000_O_$1 [options] <inputfile> [options]'#000+ - '11001_W_Only one source file supp','orted, changing source file to comp'+ - 'ile from "$1" into "$2"'#000+ + '11001_W_Only one source file supported, changing source file to compil'+ + 'e from "$1" into "$2"'#000+ '11002_W_DEF file can be created only for OS/2'#000+ '11003_E_nested response files are not supported'#000+ - '11004_F_No source file name in command line'#000+ + '11004_','F_No source file name in command line'#000+ '11005_N_No option inside $1 config file'#000+ - '110','06_E_Illegal parameter: $1'#000+ + '11006_E_Illegal parameter: $1'#000+ '11007_H_-? writes help pages'#000+ '11008_F_Too many config files nested'#000+ '11009_F_Unable to open file $1'#000+ - '11010_D_Reading further options from $1'#000+ + '11010_D_Reading further options fro','m $1'#000+ '11011_W_Target is already set to: $1'#000+ - '11012_W_Shared libs not supported on DO','S platform, reverting to stat'+ - 'ic'#000+ + '11012_W_Shared libs not supported on DOS platform, reverting to static'+ + #000+ '11013_F_In options file $1 at line $2 too many \var{\#IF(N)DEFs} encou'+ 'ntered'#000+ - '11014_F_In options file $1 at line $2 unexpected \var{\#ENDIFs} encoun'+ - 'tered'#000+ - '11015_F_Open conditional at the end of the options file',#000+ + '11014_F_In options file $1 at line $2 unexpected \','var{\#ENDIFs} enco'+ + 'untered'#000+ + '11015_F_Open conditional at the end of the options file'#000+ '11016_W_Debug information generation is not supported by this executab'+ 'le'#000+ '11017_H_Try recompiling with -dGDB'#000+ '11018_W_You are using the obsolete switch $1'#000+ - '11019_W_You are using the obsolete switch $1, please use $2'#000+ - '11020_N_Switching assemble','r to default source writing assembler'#000+ + '11019','_W_You are using the obsolete switch $1, please use $2'#000+ + '11020_N_Switching assembler to default source writing assembler'#000+ '11021_W_Assembler output selected "$1" is not compatible with "$2"'#000+ '11022_W_"$1" assembler use forced'#000+ - '11026_T_Reading options from file $1'#000+ + '11026_T_Reading opti','ons from file $1'#000+ '11027_T_Reading options from environment $1'#000+ - '11028_D_Handling opt','ion "$1"'#000+ + '11028_D_Handling option "$1"'#000+ '11029_O_*** press enter ***'#000+ '11030_H_Start of reading config file $1'#000+ '11031_H_End of reading config file $1'#000+ '11032_D_interpreting option "$1"'#000+ - '11036_D_interpreting firstpass option "$1"'#000+ + '11036_D_int','erpreting firstpass option "$1"'#000+ '11033_D_interpreting file option "$1"'#000+ - '11034_D_Rea','ding config file "$1"'#000+ + '11034_D_Reading config file "$1"'#000+ '11035_D_found source file name "$1"'#000+ '11039_E_Unknown codepage "$1"'#000+ '11040_F_Config file $1 is a directory'#000+ - '11041_W_Assembler output selected "$1" cannot generate debug info, deb'+ - 'ugging disabled'#000+ - '11042_W_Use of ppc386.cfg is',' deprecated, please use fpc.cfg instead'#000+ + '11041_W_Assembler output selected',' "$1" cannot generate debug info, d'+ + 'ebugging disabled'#000+ + '11042_W_Use of ppc386.cfg is deprecated, please use fpc.cfg instead'#000+ '11043_F_In options file $1 at line $2 \var{\#ELSE} directive without \'+ 'var{\#IF(N)DEF} found'#000+ - '11044_F_Option "$1" is not, or not yet, supported on the current targe'+ - 't platform'#000+ - '11045_F_The feature "$1" is',' not, or not yet, supported on the select'+ - 'ed target platform'#000+ + '11044_F_Option "$1" is not,',' or not yet, supported on the current tar'+ + 'get platform'#000+ + '11045_F_The feature "$1" is not, or not yet, supported on the selected'+ + ' target platform'#000+ '11046_N_DWARF debug information cannot be used with smart linking on t'+ - 'his target, switching to static linking'#000+ + 'his target, switching to stat','ic linking'#000+ '11047_W_Option "$1" is ignored for the current target platform.'#000+ - '11048_','W_Disabling external debug information because it is unsupport'+ - 'ed for the selected target/debug format combination.'#000+ - '11049_N_DWARF debug information cannot be used with smart linking with'+ - ' external assembler, disabling static library creation.',#000+ + '11048_W_Disabling external debug information because it is unsupported'+ + ' for the selected target/debug format combination.'#000+ + '11049_N_DWARF debug information cannot be us','ed with smart linking wi'+ + 'th external assembler, disabling static library creation.'#000+ '11050_E_Invalid value for MACOSX_DEPLOYMENT_TARGET environment variabl'+ 'e: $1'#000+ '11051_E_Invalid value for IPHONEOS_DEPLOYMENT_TARGET environment varia'+ 'ble: $1'#000+ - '11052_E_You must use a FPU type of VFPV2, VFPV3 or VFPV3_D16 when usin'+ - 'g the EABIHF AB','I target'#000+ + '1105','2_E_You must use a FPU type of VFPV2, VFPV3 or VFPV3_D16 when us'+ + 'ing the EABIHF ABI target'#000+ '12000_F_Cannot open whole program optimization feedback file "$1"'#000+ '12001_D_Processing whole program optimization information in wpo feedb'+ - 'ack file "$1"'#000+ + 'ack file "$1"'#000, '12002_D_Finished processing the whole program optimization information'+ - ' in wpo fee','dback file "$1"'#000+ + ' in wpo feedback file "$1"'#000+ '12003_E_Expected section header, but got "$2" at line $1 of wpo feedba'+ 'ck file'#000+ - '12004_W_No handler registered for whole program optimization section "'+ - '$2" at line $1 of wpo feedback file, ignoring'#000+ - '12005_D_Found whole program op','timization section "$1" with informati'+ - 'on about "$2"'#000+ + '12004_W_No handler registered for whole program optimization sect','ion'+ + ' "$2" at line $1 of wpo feedback file, ignoring'#000+ + '12005_D_Found whole program optimization section "$1" with information'+ + ' about "$2"'#000+ '12006_F_The selected whole program optimizations require a previously '+ - 'generated feedback file (use -Fw to specify)'#000+ + 'generated feedback file (use -Fw to s','pecify)'#000+ '12007_E_No collected information necessary to perform "$1" whole progr'+ - 'am ','optimization found'#000+ + 'am optimization found'#000+ '12008_F_Specify a whole program optimization feedback file to store th'+ 'e generated info in (using -FW)'#000+ - '12009_E_Not generating any whole program optimization information, yet'+ - ' a feedback file was specified (using -FW)'#000+ - '12010_','E_Not performing any whole program optimizations, yet an input'+ - ' feedback file was specified (using -Fw)'#000+ - '12011_D_Skipping whole program optimization section "$1", because not '+ - 'needed by the requested optimizations'#000+ - '12012_W_Overriding previously',' read information for "$1" from feedbac'+ - 'k input file using information in section "$2"'#000+ + '12009_E_Not generating any whole progr','am optimization information, y'+ + 'et a feedback file was specified (using -FW)'#000+ + '12010_E_Not performing any whole program optimizations, yet an input f'+ + 'eedback file was specified (using -Fw)'#000+ + '12011_D_Skipping whole program optimization section "$1"',', because no'+ + 't needed by the requested optimizations'#000+ + '12012_W_Overriding previously read information for "$1" from feedback '+ + 'input file using information in section "$2"'#000+ '12013_E_Cannot extract symbol liveness information from program when s'+ - 'tripping symbols, use -Xs-'#000+ - '12014_E_Cannot extract symbol liveness information from p','rogram when'+ - ' when not linking'#000+ + 'tri','pping symbols, use -Xs-'#000+ + '12014_E_Cannot extract symbol liveness information from program when w'+ + 'hen not linking'#000+ '12015_F_Cannot find "$1" or "$2" to extract symbol liveness informatio'+ 'n from linked program'#000+ - '12016_E_Error during reading symbol liveness information produced by "'+ - '$1"'#000+ - '12017_F_Error executing "$1" (exitcode: $2) t','o extract symbol inform'+ - 'ation from linked program'#000+ + '12016_E_Error during reading symbol li','veness information produced by'+ + ' "$1"'#000+ + '12017_F_Error executing "$1" (exitcode: $2) to extract symbol informat'+ + 'ion from linked program'#000+ '12018_E_Collection of symbol liveness information can only help when u'+ 'sing smart linking, use -CX -XX'#000+ - '12019_E_Cannot create specified whole program optimisation feedback fi'+ - 'le "$1"'#000+ - '11023_Free ','Pascal Compiler version $FPCFULLVERSION [$FPCDATE] for $F'+ - 'PCCPU'#010+ + '12019_E_','Cannot create specified whole program optimisation feedback '+ + 'file "$1"'#000+ + '11023_Free Pascal Compiler version $FPCFULLVERSION [$FPCDATE] for $FPC'+ + 'CPU'#010+ 'Copyright (c) 1993-2012 by Florian Klaempfl and others'#000+ - '11024_Free Pascal Compiler version $FPCVERSION'#010+ + '11024_Free Pascal Compiler version $FPCVE','RSION'#010+ #010+ 'Compiler Date : $FPCDATE'#010+ 'Compiler CPU Target: $FPCCPU'#010+ #010+ - 'Supported targ','ets:'#010+ + 'Supported targets:'#010+ ' $OSTARGETS'#010+ #010+ 'Supported CPU instruction sets:'#010+ @@ -1167,12 +1173,12 @@ const msgtxt : array[0..000277,1..240] of char=( ' $FPUINSTRUCTIONSETS'#010+ #010+ 'Supported ABI targets:'#010+ - ' $ABITARGETS'#010+ + ' $ABITARG','ETS'#010+ #010+ 'Supported Optimizations:'#010+ ' $OPTIMIZATIONS'#010+ #010+ - 'Supported Whole Program Optimizat','ions:'#010+ + 'Supported Whole Program Optimizations:'#010+ ' All'#010+ ' $WPOPTIMIZATIONS'#010+ #010+ @@ -1180,360 +1186,362 @@ const msgtxt : array[0..000277,1..240] of char=( ' $CONTROLLERTYPES'#010+ #010+ 'This program comes under the GNU General Public Licence'#010+ - 'For more information read COPYING.v2'#010+ + 'For more informati','on read COPYING.v2'#010+ #010+ 'Please report bugs in our bug tracker on:'#010+ - ' ht','tp://bugs.freepascal.org'#010+ + ' http://bugs.freepascal.org'#010+ #010+ 'More information may be found on our WWW pages (including directions'#010+ - 'for mailing lists useful for asking questions or discussing potential'#010+ + 'for mailing lists useful for asking questions or discussing pote','ntia'+ + 'l'#010+ 'new features, etc.):'#010+ ' http://www.freepascal.org'#000+ - '11025_**0*_','Put + after a boolean switch option to enable it, - to di'+ - 'sable it'#010+ + '11025_**0*_Put + after a boolean switch option to enable it, - to disa'+ + 'ble it'#010+ '**1a_The compiler doesn'#039't delete the generated assembler file'#010+ - '**2al_List sourcecode lines in assembler file'#010+ + '**2al_List sourcecode lines in ','assembler file'#010+ '**2an_List node info in assembler file (-dEXTDEBUG compiler)'#010+ - '*L2ap','_Use pipes instead of creating temporary assembler files'#010+ + '*L2ap_Use pipes instead of creating temporary assembler files'#010+ '**2ar_List register allocation/release info in assembler file'#010+ - '**2at_List temp allocation/release info in assembler file'#010+ + '**2at_List temp allocation/release info ','in assembler file'#010+ '**1A<x>_Output format:'#010+ '**2Adefault_Use default assembler'#010+ - '3*2Aas','_Assemble using GNU AS'#010+ + '3*2Aas_Assemble using GNU AS'#010+ '3*2Amacho_Mach-O (Darwin, Intel 32 bit) using internal writer'#010+ '3*2Anasmcoff_COFF (Go32v2) file using Nasm'#010+ - '3*2Anasmelf_ELF32 (Linux) file using Nasm'#010+ + '3*2Anasmelf_ELF32 (Linux) file ','using Nasm'#010+ '3*2Anasmwin32_Win32 object file using Nasm'#010+ - '3*2Anasmwdosx_Win32/WDOSX o','bject file using Nasm'#010+ + '3*2Anasmwdosx_Win32/WDOSX object file using Nasm'#010+ '3*2Awasm_Obj file using Wasm (Watcom)'#010+ '3*2Anasmobj_Obj file using Nasm'#010+ '3*2Amasm_Obj file using Masm (Microsoft)'#010+ - '3*2Atasm_Obj file using Tasm (Borland)'#010+ + '3*2Atasm_Obj file using Ta','sm (Borland)'#010+ '3*2Aelf_ELF (Linux) using internal writer'#010+ - '3*2Acoff_COFF (Go32v2) usi','ng internal writer'#010+ + '3*2Acoff_COFF (Go32v2) using internal writer'#010+ '3*2Apecoff_PE-COFF (Win32) using internal writer'#010+ '4*2Aas_Assemble using GNU AS'#010+ '4*2Agas_Assemble using GNU GAS'#010+ - '4*2Agas-darwin_Assemble darwin Mach-O64 using GNU GAS'#010+ + '4*2Agas-darwin_Assemble darwin ','Mach-O64 using GNU GAS'#010+ '4*2Amasm_Win64 object file using ml64 (Microsoft)'#010+ - '4*2Apeco','ff_PE-COFF (Win64) using internal writer'#010+ + '4*2Apecoff_PE-COFF (Win64) using internal writer'#010+ '4*2Aelf_ELF (Linux-64bit) using internal writer'#010+ '6*2Aas_Unix o-file using GNU AS'#010+ '6*2Agas_GNU Motorola assembler'#010+ - '6*2Amit_MIT Syntax (old GAS)'#010+ + '6*2Amit','_MIT Syntax (old GAS)'#010+ '6*2Amot_Standard Motorola assembler'#010+ - 'A*2Aas_Assemble using G','NU AS'#010+ + 'A*2Aas_Assemble using GNU AS'#010+ 'P*2Aas_Assemble using GNU AS'#010+ 'S*2Aas_Assemble using GNU AS'#010+ '**1b_Generate browser info'#010+ '**2bl_Generate local symbol info'#010+ '**1B_Build all modules'#010+ - '**1C<x>_Code generation options:'#010+ + '**1C<x>_Code',' generation options:'#010+ '**2C3<x>_Turn on ieee error checking for constants'#010+ - '**2Ca<x>_','Select ABI, see fpc -i for possible values'#010+ + '**2Ca<x>_Select ABI, see fpc -i for possible values'#010+ '**2Cb_Generate big-endian code'#010+ '**2Cc<x>_Set default calling convention to <x>'#010+ - '**2CD_Create also dynamic library (not supported)'#010+ + '**2CD_Create also dynamic library (not',' supported)'#010+ '**2Ce_Compilation with emulated floating point opcodes'#010+ - '**2Cf<x>_Selec','t fpu instruction set to use, see fpc -i for possible '+ - 'values'#010+ + '**2Cf<x>_Select fpu instruction set to use, see fpc -i for possible va'+ + 'lues'#010+ '**2CF<x>_Minimal floating point constant precision (default, 32, 64)'#010+ '**2Cg_Generate PIC code'#010+ - '**2Ch<n>_<n> bytes heap (between 1023 and 67107840)'#010+ + '**2Ch','<n>_<n> bytes heap (between 1023 and 67107840)'#010+ '**2Ci_IO-checking'#010+ - '**2Cn_Omit linki','ng stage'#010+ + '**2Cn_Omit linking stage'#010+ 'P*2CN_Generate nil-pointer checks (AIX-only)'#010+ '**2Co_Check overflow of integer operations'#010+ '**2CO_Check for possible overflow of integer operations'#010+ - '**2Cp<x>_Select instruction set, see fpc -i for possible values'#010+ - '**2CP<x>=<y>_ packing s','ettings'#010+ + '**2Cp<','x>_Select instruction set, see fpc -i for possible values'#010+ + '**2CP<x>=<y>_ packing settings'#010+ '**3CPPACKSET=<y>_ <y> set allocation: 0, 1 or DEFAULT or NORMAL, 2, 4 '+ 'and 8'#010+ '**2Cr_Range checking'#010+ '**2CR_Verify object method call validity'#010+ - '**2Cs<n>_Set stack checking size to <n>'#010+ + '**2Cs<n>_Set ','stack checking size to <n>'#010+ '**2Ct_Stack checking (for testing only, see manual)'#010+ - 'p*','2CT<x>_Target-specific code generation options'#010+ + 'p*2CT<x>_Target-specific code generation options'#010+ 'P*2CT<x>_Target-specific code generation options'#010+ 'J*2CT<x>_Target-specific code generation options'#010+ - 'p*3CTsmalltoc_ Generate smaller TOCs at the expense of execution speed'+ - ' (AIX)'#010+ - 'P*3CTsmalltoc_ Gen','erate smaller TOCs at the expense of execution spe'+ + 'p*3CTsmalltoc_',' Generate smaller TOCs at the expense of execution spe'+ 'ed (AIX)'#010+ + 'P*3CTsmalltoc_ Generate smaller TOCs at the expense of execution speed'+ + ' (AIX)'#010+ 'J*3CTcompactintarrayinit_ Generate smaller (but potentially slower) co'+ - 'de for initializing integer array constants'#010+ - 'K*3CTenumfieldinit_ Initialize enumeration fields in constructors t','o'+ - ' enumtype(0), after calling inherited constructors'#010+ + 'de for initializing integer ar','ray constants'#010+ + 'K*3CTenumfieldinit_ Initialize enumeration fields in constructors to e'+ + 'numtype(0), after calling inherited constructors'#010+ 'J*2Cv_Var/out parameter copy-out checking'#010+ '**2CX_Create also smartlinked library'#010+ - '**1d<x>_Defines the symbol <x>'#010+ + '**1d<x>_Defines the symbol ','<x>'#010+ '**1D_Generate a DEF file'#010+ '**2Dd<x>_Set description to <x>'#010+ - '**2Dv<x>_Set DLL ver','sion to <x>'#010+ + '**2Dv<x>_Set DLL version to <x>'#010+ '*O2Dw_PM application'#010+ '**1e<x>_Set path to executable'#010+ '**1E_Same as -Cn'#010+ '**1fPIC_Same as -Cg'#010+ '**1F<x>_Set file names and paths:'#010+ - '**2Fa<x>[,y]_(for a program) load units <x> and [y] before uses is par'+ - 'sed'#010+ - '**2Fc<x>_Set input codepage to ','<x>'#010+ + '**2Fa<x>[,y]_(for a prog','ram) load units <x> and [y] before uses is p'+ + 'arsed'#010+ + '**2Fc<x>_Set input codepage to <x>'#010+ '**2FC<x>_Set RC compiler binary name to <x>'#010+ '**2Fd_Disable the compiler'#039's internal directory cache'#010+ - '**2FD<x>_Set the directory where to search for compiler utilities'#010+ + '**2FD<x>_Set the directory where to search for compiler u','tilities'#010+ '**2Fe<x>_Redirect error output to <x>'#010+ - '**2Ff<x>_Add <x> to framework path',' (Darwin only)'#010+ + '**2Ff<x>_Add <x> to framework path (Darwin only)'#010+ '**2FE<x>_Set exe/unit output path to <x>'#010+ '**2Fi<x>_Add <x> to include path'#010+ '**2Fl<x>_Add <x> to library path'#010+ '**2FL<x>_Use <x> as dynamic linker'#010+ - '**2Fm<x>_Load unicode conversion table from <x>.txt in the compiler di'+ - 'r'#010+ - '**2Fo<x>_Ad','d <x> to object path'#010+ + '**','2Fm<x>_Load unicode conversion table from <x>.txt in the compiler '+ + 'dir'#010+ + '**2Fo<x>_Add <x> to object path'#010+ '**2Fr<x>_Load error message file <x>'#010+ '**2FR<x>_Set resource (.res) linker to <x>'#010+ '**2Fu<x>_Add <x> to unit path'#010+ - '**2FU<x>_Set unit output path to <x>, overrides -FE'#010+ - '**2FW<x>_Store generated whole-program optimization feedb','ack in <x>'#010+ + '**2FU<x>_Set unit output pat','h to <x>, overrides -FE'#010+ + '**2FW<x>_Store generated whole-program optimization feedback in <x>'#010+ '**2Fw<x>_Load previously stored whole-program optimization feedback fr'+ 'om <x>'#010+ '*g1g_Generate debug information (default format for target)'#010+ - '*g2gc_Generate checks for pointers'#010+ - '*g2gh_Use heaptrace unit (for memory leak/corruption debu','gging)'#010+ + '*g2gc_Gener','ate checks for pointers'#010+ + '*g2gh_Use heaptrace unit (for memory leak/corruption debugging)'#010+ '*g2gl_Use line info unit (show more info with backtraces)'#010+ '*g2go<x>_Set debug information options'#010+ - '*g3godwarfsets_ Enable DWARF '#039'set'#039' type debug information (bre'+ - 'aks gdb < 6.5)'#010+ - '*g3gostabsabsincludes_ Store absolute/full include file pat','hs in Sta'+ - 'bs'#010+ + '*g3godwarfsets_ Enable DWARF '#039'set'#039' type debug informati','on (b'+ + 'reaks gdb < 6.5)'#010+ + '*g3gostabsabsincludes_ Store absolute/full include file paths in Stabs'+ + #010+ '*g3godwarfmethodclassprefix_ Prefix method names in DWARF with class n'+ 'ame'#010+ '*g2gp_Preserve case in stabs symbol names'#010+ - '*g2gs_Generate Stabs debug information'#010+ + '*g2gs_Generate Stabs debug info','rmation'#010+ '*g2gt_Trash local variables (to detect uninitialized uses)'#010+ - '*g2gv_Generate','s programs traceable with Valgrind'#010+ + '*g2gv_Generates programs traceable with Valgrind'#010+ '*g2gw_Generate DWARFv2 debug information (same as -gw2)'#010+ '*g2gw2_Generate DWARFv2 debug information'#010+ - '*g2gw3_Generate DWARFv3 debug information'#010+ + '*g2gw3_Generate DWARFv3 de','bug information'#010+ '*g2gw4_Generate DWARFv4 debug information (experimental)'#010+ - '**1i_Inf','ormation'#010+ + '**1i_Information'#010+ '**2iD_Return compiler date'#010+ '**2iV_Return short compiler version'#010+ '**2iW_Return full compiler version'#010+ '**2iSO_Return compiler OS'#010+ - '**2iSP_Return compiler host processor'#010+ + '**2iSP_Return compiler hos','t processor'#010+ '**2iTO_Return target OS'#010+ '**2iTP_Return target processor'#010+ - '**1I<x>_Add <x','> to include path'#010+ + '**1I<x>_Add <x> to include path'#010+ '**1k<x>_Pass <x> to the linker'#010+ '**1l_Write logo'#010+ '**1M<x>_Set language mode to <x>'#010+ '**2Mfpc_Free Pascal dialect (default)'#010+ - '**2Mobjfpc_FPC mode with Object Pascal support'#010+ + '**2Mobjfpc_FPC mode wit','h Object Pascal support'#010+ '**2Mdelphi_Delphi 7 compatibility mode'#010+ - '**2Mtp_TP/BP 7.0 c','ompatibility mode'#010+ + '**2Mtp_TP/BP 7.0 compatibility mode'#010+ '**2Mmacpas_Macintosh Pascal dialects compatibility mode'#010+ '**1n_Do not read the default config files'#010+ - '**1o<x>_Change the name of the executable produced to <x>'#010+ + '**1o<x>_Change the name of the executable p','roduced to <x>'#010+ '**1O<x>_Optimizations:'#010+ '**2O-_Disable optimizations'#010+ - '**2O1_Level 1 o','ptimizations (quick and debugger friendly)'#010+ + '**2O1_Level 1 optimizations (quick and debugger friendly)'#010+ '**2O2_Level 2 optimizations (-O1 + quick optimizations)'#010+ '**2O3_Level 3 optimizations (-O2 + slow optimizations)'#010+ - '**2O4_Level 4 optimizations (-O3 + optimizations which might have unex'+ - 'pected side effe','cts)'#010+ + '**2O4','_Level 4 optimizations (-O3 + optimizations which might have un'+ + 'expected side effects)'#010+ '**2Oa<x>=<y>_Set alignment'#010+ '**2Oo[NO]<x>_Enable or disable optimizations, see fpc -i for possible '+ 'values'#010+ - '**2Op<x>_Set target cpu for optimizing, see fpc -i for possible values'+ - #010+ - '**2OW<x>_Generate whole-program optimization feedback for op','timizati'+ - 'on <x>, see fpc -i for possible values'#010+ + '**2Op<x>_Set target cpu for optimizing, see fpc -i',' for possible valu'+ + 'es'#010+ + '**2OW<x>_Generate whole-program optimization feedback for optimization'+ + ' <x>, see fpc -i for possible values'#010+ '**2Ow<x>_Perform whole-program optimization <x>, see fpc -i for possib'+ 'le values'#010+ - '**2Os_Optimize for size rather than speed'#010+ + '**2Os_Optimize for size rather t','han speed'#010+ '**1pg_Generate profile code for gprof (defines FPC_PROFILE)'#010+ - 'F*1P<x>_Tar','get CPU / compiler related options:'#010+ + 'F*1P<x>_Target CPU / compiler related options:'#010+ 'F*2PB_Show default compiler binary'#010+ 'F*2PP_Show default target cpu'#010+ - 'F*2P<x>_Set target CPU (arm,i386,m68k,mips,mipsel,powerpc,powerpc64,sp'+ - 'arc,x86_64'#010+ + 'F*2P<x>_Set target CPU (arm,i386,m68k,mips,mipsel,powerpc,','powerpc64,'+ + 'sparc,x86_64'#010+ '**1R<x>_Assembler reading style:'#010+ - '**2Rdefault_Use default a','ssembler for target'#010+ + '**2Rdefault_Use default assembler for target'#010+ '3*2Ratt_Read AT&T style assembler'#010+ '3*2Rintel_Read Intel style assembler'#010+ '6*2RMOT_Read motorola style assembler'#010+ '**1S<x>_Syntax options:'#010+ - '**2S2_Same as -Mobjfpc'#010+ + '**2S2_','Same as -Mobjfpc'#010+ '**2Sc_Support operators like C (*=,+=,/= and -=)'#010+ - '**2Sa_Turn on a','ssertions'#010+ + '**2Sa_Turn on assertions'#010+ '**2Sd_Same as -Mdelphi'#010+ '**2Se<x>_Error options. <x> is a combination of the following:'#010+ '**3*_<n> : Compiler halts after the <n> errors (default is 1)'#010+ - '**3*_w : Compiler also halts after warnings'#010+ - '**3*_n : Compiler also halts after not','es'#010+ + '*','*3*_w : Compiler also halts after warnings'#010+ + '**3*_n : Compiler also halts after notes'#010+ '**3*_h : Compiler also halts after hints'#010+ '**2Sg_Enable LABEL and GOTO (default in -Mtp and -Mdelphi)'#010+ - '**2Sh_Use reference counted strings (ansistring by default) instead of'+ - ' shortstrings'#010+ - '**2Si_Turn on inlining of procedures/functions declar','ed as "inline"'#010+ + '**2Sh_Use reference counted strings (ansistring by defau','lt) instead '+ + 'of shortstrings'#010+ + '**2Si_Turn on inlining of procedures/functions declared as "inline"'#010+ '**2Sk_Load fpcylix unit'#010+ '**2SI<x>_Set interface style to <x>'#010+ '**3SIcom_COM compatible interface (default)'#010+ '**3SIcorba_CORBA compatible interface'#010+ - '**2Sm_Support macros like C (global)'#010+ + '**','2Sm_Support macros like C (global)'#010+ '**2So_Same as -Mtp'#010+ - '**2Ss_Constructor name must',' be init (destructor must be done)'#010+ + '**2Ss_Constructor name must be init (destructor must be done)'#010+ '**2Sx_Enable exception keywords (default in Delphi/ObjFPC modes)'#010+ '**2Sy_@<pointer> returns a typed pointer, same as $T+'#010+ - '**1s_Do not call assembler and linker'#010+ + '**1s_','Do not call assembler and linker'#010+ '**2sh_Generate script to link on host'#010+ - '**2st_Gene','rate script to link on target'#010+ + '**2st_Generate script to link on target'#010+ '**2sr_Skip register allocation phase (use with -alr)'#010+ '**1T<x>_Target operating system:'#010+ '3*2Tdarwin_Darwin/Mac OS X'#010+ - '3*2Temx_OS/2 via EMX (including EMX/RSX extender)'#010+ + '3*2Temx_OS/2 via',' EMX (including EMX/RSX extender)'#010+ '3*2Tfreebsd_FreeBSD'#010+ - '3*2Tgo32v2_Version 2 of DJ ','Delorie DOS extender'#010+ + '3*2Tgo32v2_Version 2 of DJ Delorie DOS extender'#010+ '3*2Tiphonesim_ iPhoneSimulator from iOS SDK 3.2+ (older versions: -Tda'+ 'rwin)'#010+ '3*2Tlinux_Linux'#010+ '3*2Tnetbsd_NetBSD'#010+ - '3*2Tnetware_Novell Netware Module (clib)'#010+ + '3*2Tnetware_Novell Netware M','odule (clib)'#010+ '3*2Tnetwlibc_Novell Netware Module (libc)'#010+ '3*2Topenbsd_OpenBSD'#010+ - '3*2Tos','2_OS/2 / eComStation'#010+ + '3*2Tos2_OS/2 / eComStation'#010+ '3*2Tsunos_SunOS/Solaris'#010+ '3*2Tsymbian_Symbian OS'#010+ '3*2Tsolaris_Solaris'#010+ '3*2Twatcom_Watcom compatible DOS extender'#010+ - '3*2Twdosx_WDOSX DOS extender'#010+ + '3*2Twdosx_WDOSX DOS extender'#010, '3*2Twin32_Windows 32 Bit'#010+ '3*2Twince_Windows CE'#010+ '4*2Tdarwin_Darwin/Mac OS X'#010+ - '4*2Tlinu','x_Linux'#010+ + '4*2Tlinux_Linux'#010+ '4*2Twin64_Win64 (64 bit Windows systems)'#010+ '6*2Tamiga_Commodore Amiga'#010+ '6*2Tatari_Atari ST/STe/TT'#010+ '6*2Tlinux_Linux'#010+ '6*2Tpalmos_PalmOS'#010+ - 'A*2Tdarwin_Darwin/iPhoneOS/iOS'#010+ + 'A*2Tdarwin_Darwin/iPhone','OS/iOS'#010+ 'A*2Tlinux_Linux'#010+ 'A*2Twince_Windows CE'#010+ 'P*2Tamiga_AmigaOS'#010+ - 'P*2Tdarwin_Darwin/M','ac OS X'#010+ + 'P*2Tdarwin_Darwin/Mac OS X'#010+ 'P*2Tlinux_Linux'#010+ 'P*2Tmacos_Mac OS (classic)'#010+ 'P*2Tmorphos_MorphOS'#010+ 'S*2Tsolaris_Solaris'#010+ 'S*2Tlinux_Linux'#010+ '**1u<x>_Undefines the symbol <x>'#010+ - '**1U_Unit options:'#010+ + '**1U_Unit options:'#010, '**2Un_Do not check where the unit name matches the file name'#010+ - '**2Ur_Generate relea','se unit files (never automatically recompiled)'#010+ + '**2Ur_Generate release unit files (never automatically recompiled)'#010+ '**2Us_Compile a system unit'#010+ '**1v<x>_Be verbose. <x> is a combination of the following letters:'#010+ - '**2*_e : Show errors (default) 0 : Show nothing (except errors)'#010+ - '**2*_w : Show warnings ',' u : Show unit info'#010+ + '**2*_e : Show err','ors (default) 0 : Show nothing (except errors'+ + ')'#010+ + '**2*_w : Show warnings u : Show unit info'#010+ '**2*_n : Show notes t : Show tried/used files'#010+ '**2*_h : Show hints c : Show conditionals'#010+ - '**2*_i : Show general info d : Show debug info'#010+ - '**2*_l : Show linenumbers ',' r : Rhide/GCC compatibility mod'+ - 'e'#010+ + '**2*_i : ','Show general info d : Show debug info'#010+ + '**2*_l : Show linenumbers r : Rhide/GCC compatibility mode'#010+ '**2*_s : Show time stamps q : Show message numbers'#010+ - '**2*_a : Show everything x : Executable info (Win32 only)'#010+ + '**2*_a : Show everything x : Executable info (Wi','n32 only'+ + ')'#010+ '**2*_b : Write file names messages p : Write tree.log with parse tre'+ - 'e',#010+ + 'e'#010+ '**2*_ with full path v : Write fpcdebug.txt with'#010+ '**2*_ lots of debugging info'#010+ - '**2*_m<x>,<y> : Don'#039't show messages numbered <x> and <y>'#010+ - 'F*1V<x>_Append '#039'-<x>'#039' to the used compiler binary nam','e (e.g.'+ - ' for version)'#010+ + '**2*_m<x>,<y> : Don'#039't show me','ssages numbered <x> and <y>'#010+ + 'F*1V<x>_Append '#039'-<x>'#039' to the used compiler binary name (e.g. f'+ + 'or version)'#010+ '**1W<x>_Target-specific options (targets)'#010+ '3*2WA_Specify native type application (Windows)'#010+ - '4*2WA_Specify native type application (Windows)'#010+ + '4*2WA_Specify native type application (Windows)'#010, 'A*2WA_Specify native type application (Windows)'#010+ - '3*2Wb_Create a bundle instead of ','a library (Darwin)'#010+ + '3*2Wb_Create a bundle instead of a library (Darwin)'#010+ 'P*2Wb_Create a bundle instead of a library (Darwin)'#010+ 'p*2Wb_Create a bundle instead of a library (Darwin)'#010+ - 'A*2Wb_Create a bundle instead of a library (Darwin)'#010+ + 'A*2Wb_Create a bundle instead of a l','ibrary (Darwin)'#010+ '4*2Wb_Create a bundle instead of a library (Darwin)'#010+ - '3*2WB_Create ','a relocatable image (Windows, Symbian)'#010+ + '3*2WB_Create a relocatable image (Windows, Symbian)'#010+ '3*2WBxxxx_Set image base to xxxx (Windows, Symbian)'#010+ '4*2WB_Create a relocatable image (Windows)'#010+ - '4*2WBxxxx_Set image base to xxxx (Windows)'#010+ + '4*2WBxxxx_Set image base ','to xxxx (Windows)'#010+ 'A*2WB_Create a relocatable image (Windows, Symbian)'#010+ - 'A*2WBxxxx_S','et image base to xxxx (Windows, Symbian)'#010+ + 'A*2WBxxxx_Set image base to xxxx (Windows, Symbian)'#010+ '3*2WC_Specify console type application (EMX, OS/2, Windows)'#010+ - '4*2WC_Specify console type application (EMX, OS/2, Windows)'#010+ + '4*2WC_Specify console type application (EMX, OS/2, Windows',')'#010+ 'A*2WC_Specify console type application (Windows)'#010+ - 'P*2WC_Specify console type app','lication (Classic Mac OS)'#010+ + 'P*2WC_Specify console type application (Classic Mac OS)'#010+ '3*2WD_Use DEFFILE to export functions of DLL or EXE (Windows)'#010+ '4*2WD_Use DEFFILE to export functions of DLL or EXE (Windows)'#010+ - 'A*2WD_Use DEFFILE to export functions of DLL or EXE (Windows)'#010+ - '3*2We_Use external resources',' (Darwin)'#010+ + 'A*2WD_Use',' DEFFILE to export functions of DLL or EXE (Windows)'#010+ + '3*2We_Use external resources (Darwin)'#010+ '4*2We_Use external resources (Darwin)'#010+ 'A*2We_Use external resources (Darwin)'#010+ 'P*2We_Use external resources (Darwin)'#010+ - 'p*2We_Use external resources (Darwin)'#010+ + 'p*2We_Use external resources (Darwi','n)'#010+ '3*2WF_Specify full-screen type application (EMX, OS/2)'#010+ - '3*2WG_Specify graphic t','ype application (EMX, OS/2, Windows)'#010+ + '3*2WG_Specify graphic type application (EMX, OS/2, Windows)'#010+ '4*2WG_Specify graphic type application (EMX, OS/2, Windows)'#010+ 'A*2WG_Specify graphic type application (Windows)'#010+ - 'P*2WG_Specify graphic type application (Classic Mac OS)'#010+ - '3*2Wi_Use internal resources (Darwin)'#010, + 'P*2WG_Specify',' graphic type application (Classic Mac OS)'#010+ + '3*2Wi_Use internal resources (Darwin)'#010+ '4*2Wi_Use internal resources (Darwin)'#010+ 'A*2Wi_Use internal resources (Darwin)'#010+ 'P*2Wi_Use internal resources (Darwin)'#010+ 'p*2Wi_Use internal resources (Darwin)'#010+ - '3*2WI_Turn on/off the usage of import sections (Windows)'#010+ - '4*2WI_Turn on/off the usage of ','import sections (Windows)'#010+ + '3*2WI_T','urn on/off the usage of import sections (Windows)'#010+ + '4*2WI_Turn on/off the usage of import sections (Windows)'#010+ 'A*2WI_Turn on/off the usage of import sections (Windows)'#010+ '3*2WM<x>_Minimum Mac OS X deployment version: 10.4, 10.5.1, ... (Darwi'+ 'n)'#010+ - '4*2WM<x>_Minimum Mac OS X deployment version: 10.4, 10.5.1, ... (Darwi'+ - 'n)'#010+ - 'p*2WM<x>_Mi','nimum Mac OS X deployment version: 10.4, 10.5.1, ... (Dar'+ + '4*2','WM<x>_Minimum Mac OS X deployment version: 10.4, 10.5.1, ... (Dar'+ 'win)'#010+ + 'p*2WM<x>_Minimum Mac OS X deployment version: 10.4, 10.5.1, ... (Darwi'+ + 'n)'#010+ 'P*2WM<x>_Minimum Mac OS X deployment version: 10.4, 10.5.1, ... (Darwi'+ 'n)'#010+ - '3*2WN_Do not generate relocation code, needed for debugging (Windows)'#010+ - '4*2WN_Do not generate relocation co','de, needed for debugging (Windows'+ + '3*2WN_Do not generate re','location code, needed for debugging (Windows'+ ')'#010+ + '4*2WN_Do not generate relocation code, needed for debugging (Windows)'#010+ 'A*2WN_Do not generate relocation code, needed for debugging (Windows)'#010+ - 'A*2Wpxxxx_Specify the controller type, see fpc -i for possible values'#010+ - 'V*2Wpxxxx_Specify the controller type, see fpc -i for possible va','lue'+ + 'A*2Wpxxxx_Specify the controller type, see fpc -i for ','possible value'+ 's'#010+ + 'V*2Wpxxxx_Specify the controller type, see fpc -i for possible values'#010+ '3*2WP<x>_Minimum iOS deployment version: 3.0, 5.0.1, ... (iphonesim)'#010+ 'A*2WP<x>_Minimum iOS deployment version: 3.0, 5.0.1, ... (Darwin)'#010+ - '3*2WR_Generate relocation code (Windows)'#010+ + '3*2WR_Generate relo','cation code (Windows)'#010+ '4*2WR_Generate relocation code (Windows)'#010+ - 'A*2WR_Generate rel','ocation code (Windows)'#010+ + 'A*2WR_Generate relocation code (Windows)'#010+ 'P*2WT_Specify MPW tool type application (Classic Mac OS)'#010+ '**2WX_Enable executable stack (Linux)'#010+ '**1X_Executable options:'#010+ - '**2Xc_Pass --shared/-dynamic to the linker (BeOS, Darwin, FreeBSD, Lin'+ - 'ux)'#010+ - '**2Xd_Do not search def','ault library path (sometimes required for cro'+ - 'ss-compiling when not using -XR)'#010+ + '**2Xc_Pass --sha','red/-dynamic to the linker (BeOS, Darwin, FreeBSD, L'+ + 'inux)'#010+ + '**2Xd_Do not search default library path (sometimes required for cross'+ + '-compiling when not using -XR)'#010+ '**2Xe_Use external linker'#010+ - '**2Xg_Create debuginfo in a separate file and add a debuglink section '+ - 'to executable'#010+ - '**2XD_Try to link units dynamically (defines FP','C_LINK_DYNAMIC)'#010+ + '**2Xg_Create debuginfo in a separate file and add a deb','uglink sectio'+ + 'n to executable'#010+ + '**2XD_Try to link units dynamically (defines FPC_LINK_DYNAMIC)'#010+ '**2Xi_Use internal linker'#010+ '**2Xm_Generate link map'#010+ '**2XM<x>_Set the name of the '#039'main'#039' program routine (default i'+ 's '#039'main'#039')'#010+ - 'F*2Xp<x>_First search for the compiler binary in the directory <x>'#010+ - '**2XP<x>_Prepend the binutils names',' with the prefix <x>'#010+ + 'F*2Xp<x>_First search',' for the compiler binary in the directory <x>'#010+ + '**2XP<x>_Prepend the binutils names with the prefix <x>'#010+ '**2Xr<x>_Set the linker'#039's rlink-path to <x> (needed for cross comp'+ 'ile, see the ld manual for more information) (BeOS, Linux)'#010+ - '**2XR<x>_Prepend <x> to all linker search paths (BeOS, Darwin, FreeBSD'+ - ', Linux, Mac OS, Solaris',')'#010+ + '**2XR<x>_Prep','end <x> to all linker search paths (BeOS, Darwin, FreeB'+ + 'SD, Linux, Mac OS, Solaris)'#010+ '**2Xs_Strip all symbols from executable'#010+ '**2XS_Try to link units statically (default, defines FPC_LINK_STATIC)'#010+ - '**2Xt_Link with static libraries (-static is passed to linker)'#010+ - '**2XX_Try to smartlink units (defines FPC_LINK_SMART)',#010+ + '**2Xt_Link with static libraries (-static is pa','ssed to linker)'#010+ + '**2XX_Try to smartlink units (defines FPC_LINK_SMART)'#010+ '**1*_'#010+ '**1?_Show this help'#010+ '**1h_Shows this help without waiting' diff --git a/compiler/pp.lpi b/compiler/pp.lpi index 5600b59264..2cc1a85cbb 100644 --- a/compiler/pp.lpi +++ b/compiler/pp.lpi @@ -25,7 +25,13 @@ <RunParams> <local> <FormatVersion Value="1"/> + <CommandLineParams Value="@c:\fpc\bin\fpc.cfg c:\fpc\branches\trunk\tests\webtbs\tw3863.pp -al"/> </local> + <environment> + <UserOverrides Count="1"> + <Variable0 Name="MYFPC" Value="branches\trunk\"/> + </UserOverrides> + </environment> </RunParams> <Units Count="1"> <Unit0> diff --git a/compiler/ppcgen/cgppc.pas b/compiler/ppcgen/cgppc.pas index 5c6d43885e..0974fcd714 100644 --- a/compiler/ppcgen/cgppc.pas +++ b/compiler/ppcgen/cgppc.pas @@ -159,8 +159,8 @@ unit cgppc; cgsize_strings : array[TCgSize] of string[8] = ( 'OS_NO', 'OS_8', 'OS_16', 'OS_32', 'OS_64', 'OS_128', 'OS_S8', 'OS_S16', 'OS_S32', 'OS_S64', 'OS_S128', 'OS_F32', 'OS_F64', 'OS_F80', 'OS_C64', 'OS_F128', - 'OS_M8', 'OS_M16', 'OS_M32', 'OS_M64', 'OS_M128', 'OS_MS8', 'OS_MS16', 'OS_MS32', - 'OS_MS64', 'OS_MS128'); + 'OS_M8', 'OS_M16', 'OS_M32', 'OS_M64', 'OS_M128', 'OS_M256', 'OS_MS8', 'OS_MS16', 'OS_MS32', + 'OS_MS64', 'OS_MS128', 'OS_MS256'); begin result := cgsize_strings[size]; end; diff --git a/compiler/rautils.pas b/compiler/rautils.pas index 12289fbd62..e4e1a30c26 100644 --- a/compiler/rautils.pas +++ b/compiler/rautils.pas @@ -79,8 +79,8 @@ type OPR_NONE : (); OPR_CONSTANT : (val:aint); OPR_SYMBOL : (symbol:tasmsymbol;symofs:aint); - OPR_REFERENCE : (ref:treference); - OPR_LOCAL : (localsym:tabstractnormalvarsym;localsymofs:aint;localindexreg:tregister;localscale:byte;localgetoffset,localforceref:boolean); + OPR_REFERENCE : (varsize:asizeint; constoffset: asizeint; ref:treference); + OPR_LOCAL : (localvarsize, localconstoffset: asizeint;localsym:tabstractnormalvarsym;localsymofs:aint;localindexreg:tregister;localscale:byte;localgetoffset,localforceref:boolean); OPR_REGISTER : (reg:tregister); {$ifdef m68k} OPR_REGLIST : (regset : tcpuregisterset); @@ -874,16 +874,32 @@ Begin { for arrays try to get the element size, take care of multiple indexes } harrdef:=tarraydef(tabstractvarsym(sym).vardef); + + { calc array size } + if is_special_array(harrdef) then + l := -1 + else + l := harrdef.size; + + case opr.typ of + OPR_REFERENCE: opr.varsize := l; + OPR_LOCAL: opr.localvarsize := l; + end; + + while assigned(harrdef.elementdef) and (harrdef.elementdef.typ=arraydef) do harrdef:=tarraydef(harrdef.elementdef); if not is_packed_array(harrdef) then SetSize(harrdef.elesize,false) else - begin if (harrdef.elepackedbitsize mod 8) = 0 then - SetSize(harrdef.elepackedbitsize div 8,false) - end; + SetSize(harrdef.elepackedbitsize div 8,false); + end; + recorddef: + case opr.typ of + OPR_REFERENCE: opr.varsize := tabstractvarsym(sym).getsize; + OPR_LOCAL: opr.localvarsize := tabstractvarsym(sym).getsize; end; end; hasvar:=true; @@ -954,16 +970,22 @@ Begin opr.typ:=OPR_REFERENCE; Fillchar(opr.ref,sizeof(treference),0); opr.Ref.Offset:=l; + opr.varsize:=0; + opr.constoffset:=0; end; OPR_NONE : begin opr.typ:=OPR_REFERENCE; + opr.varsize:=0; + opr.constoffset:=0; Fillchar(opr.ref,sizeof(treference),0); end; OPR_REGISTER : begin reg:=opr.reg; opr.typ:=OPR_REFERENCE; + opr.varsize:=0; + opr.constoffset:=0; Fillchar(opr.ref,sizeof(treference),0); opr.Ref.base:=reg; end; @@ -972,6 +994,8 @@ Begin hsymbol:=opr.symbol; hsymofs:=opr.symofs; opr.typ:=OPR_REFERENCE; + opr.varsize:=0; + opr.constoffset:=0; Fillchar(opr.ref,sizeof(treference),0); opr.ref.symbol:=hsymbol; opr.ref.offset:=hsymofs; @@ -981,6 +1005,8 @@ Begin Message(asmr_e_invalid_operand_type); { Recover } opr.typ:=OPR_REFERENCE; + opr.varsize:=0; + opr.constoffset:=0; Fillchar(opr.ref,sizeof(treference),0); end; end; diff --git a/compiler/utils/mkx86ins.pp b/compiler/utils/mkx86ins.pp index 72cbc8b5cb..27b206c972 100644 --- a/compiler/utils/mkx86ins.pp +++ b/compiler/utils/mkx86ins.pp @@ -56,7 +56,7 @@ var function formatop(s:string;allowsizeonly:boolean):string; const - replaces=26; + replaces=28; replacetab : array[1..replaces,1..2] of string[32]=( (':',' or ot_colon'), ('reg','regnorm'), @@ -70,6 +70,8 @@ function formatop(s:string;allowsizeonly:boolean):string; ('mem16','memory or ot_bits16'), ('mem32','memory or ot_bits32'), ('mem64','memory or ot_bits64'), + ('mem128','memory or ot_bits128'), + ('mem256','memory or ot_bits256'), ('mem80','memory or ot_bits80'), ('mem','memory'), ('memory_offs','mem_offs'), @@ -269,6 +271,11 @@ begin attopcode:=Copy(s,i+1,j-i-1); { att Suffix } case attopcode[length(attopcode)] of + 'M' : + begin + dec(attopcode[0]); + attsuffix:='attsufMM'; + end; 'X' : begin dec(attopcode[0]); diff --git a/compiler/utils/mkx86reg.pp b/compiler/utils/mkx86reg.pp index bce54ba519..06967358b5 100644 --- a/compiler/utils/mkx86reg.pp +++ b/compiler/utils/mkx86reg.pp @@ -17,7 +17,7 @@ program mkx86reg; const Version = '1.00'; - max_regcount = 128; + max_regcount = 200; var s : string; i : longint; diff --git a/compiler/x86/aasmcpu.pas b/compiler/x86/aasmcpu.pas index 1c990c767f..e577d44244 100644 --- a/compiler/x86/aasmcpu.pas +++ b/compiler/x86/aasmcpu.pas @@ -51,6 +51,8 @@ interface OT_BITS16 = $00000002; OT_BITS32 = $00000004; OT_BITS64 = $00000008; { x86_64 and FPU } + OT_BITS128 = $10000000; { 16 byte SSE } + OT_BITS256 = $20000000; { 32 byte AVX } OT_BITS80 = $00000010; { FPU only } OT_FAR = $00000020; { this means 16:16 or 16:32, like in CALL/JMP } OT_NEAR = $00000040; @@ -58,7 +60,7 @@ interface { TODO: FAR/NEAR/SHORT are sizes too, they should be included into size mask, but this requires adjusting the opcode table } - OT_SIZE_MASK = $0000001F; { all the size attributes } + OT_SIZE_MASK = $3000001F; { all the size attributes } OT_NON_SIZE = longint(not OT_SIZE_MASK); { Bits 8..11: modifiers } @@ -84,6 +86,7 @@ interface otf_reg_fpu = $01000000; otf_reg_mmx = $02000000; otf_reg_xmm = $04000000; + otf_reg_ymm = $08000000; { Bits 16..19: subclasses, meaning depends on classes field } otf_sub0 = $00010000; otf_sub1 = $00020000; @@ -91,6 +94,7 @@ interface otf_sub3 = $00080000; OT_REG_SMASK = otf_sub0 or otf_sub1 or otf_sub2 or otf_sub3; + OT_REG_TYPMASK = otf_reg_cdt or otf_reg_gpr or otf_reg_sreg or otf_reg_fpu or otf_reg_mmx or otf_reg_xmm or otf_reg_ymm; { register class 0: CRx, DRx and TRx } {$ifdef x86_64} OT_REG_CDT = OT_REGISTER or otf_reg_cdt or OT_BITS64; @@ -148,18 +152,24 @@ interface OT_XMMREG = OT_REGNORM or otf_reg_xmm; OT_XMMRM = OT_REGMEM or otf_reg_xmm; + { register class 5: XMM (both reg and r/m) } + OT_YMMREG = OT_REGNORM or otf_reg_ymm; + OT_YMMRM = OT_REGMEM or otf_reg_ymm; + { Memory operands } OT_MEM8 = OT_MEMORY or OT_BITS8; OT_MEM16 = OT_MEMORY or OT_BITS16; OT_MEM32 = OT_MEMORY or OT_BITS32; OT_MEM64 = OT_MEMORY or OT_BITS64; + OT_MEM128 = OT_MEMORY or OT_BITS128; + OT_MEM256 = OT_MEMORY or OT_BITS256; OT_MEM80 = OT_MEMORY or OT_BITS80; OT_MEM_OFFS = OT_MEMORY or otf_sub0; { special type of EA } { simple [address] offset } { Matches any type of r/m operand } - OT_MEMORY_ANY = OT_MEMORY or OT_RM_GPR or OT_XMMRM or OT_MMXRM; + OT_MEMORY_ANY = OT_MEMORY or OT_RM_GPR or OT_XMMRM or OT_MMXRM or OT_YMMRM; { Immediate operands } OT_IMM8 = OT_IMMEDIATE or OT_BITS8; @@ -212,6 +222,17 @@ interface Ch : Array[1..MaxInsChanges] of TInsChange; end; + TMemRefSizeInfo = (msiUnkown, msiUnsupported, msiNoSize, msiMultiple, + msiMemRegSize, msiMemRegx64y128, msiMemRegx64y256, + msiMem8, msiMem16, msiMem32, msiMem64, msiMem128, msiMem256); + + TConstSizeInfo = (csiUnkown, csiMultiple, csiNoSize, csiMem8, csiMem16, csiMem32, csiMem64); + + TInsTabMemRefSizeInfoRec = record + MemRefSize : TMemRefSizeInfo; + ExistsSSEAVX: boolean; + ConstSize : TConstSizeInfo; + end; const InsProp : array[tasmop] of TInsProp = {$ifdef x86_64} @@ -228,7 +249,7 @@ interface ops : byte; optypes : array[0..max_operands-1] of longint; code : array[0..maxinfolen] of char; - flags : cardinal; + flags : int64; end; pinsentry=^tinsentry; @@ -313,6 +334,8 @@ interface function spilling_create_load(const ref:treference;r:tregister):Taicpu; function spilling_create_store(r:tregister; const ref:treference):Taicpu; + function MemRefInfo(aAsmop: TAsmOp): TInsTabMemRefSizeInfoRec; + procedure InitAsm; procedure DoneAsm; @@ -375,6 +398,8 @@ implementation IF_SSSE3 = $00200000; IF_SSE41 = $00200000; IF_SSE42 = $00200000; + IF_AVX = $00200000; + IF_SANDYBRIDGE = $00200000; IF_8086 = $00000000; { 8086 instruction } IF_186 = $01000000; { 186+ instruction } @@ -400,6 +425,9 @@ implementation TInsTabCache=array[TasmOp] of longint; PInsTabCache=^TInsTabCache; + TInsTabMemRefSizeInfoCache=array[TasmOp] of TInsTabMemRefSizeInfoRec; + PInsTabMemRefSizeInfoCache=^TInsTabMemRefSizeInfoCache; + const {$ifdef x86_64} InsTab:array[0..instabentries-1] of TInsEntry={$i x8664tab.inc} @@ -408,7 +436,7 @@ implementation {$endif x86_64} var InsTabCache : PInsTabCache; - + InsTabMemRefSizeInfoCache: PInsTabMemRefSizeInfoCache; const {$ifdef x86_64} { Intel style operands ! } @@ -420,7 +448,8 @@ implementation OT_BITS64, OT_NEAR,OT_FAR,OT_SHORT, OT_NONE, - OT_NONE + OT_BITS128, + OT_BITS256 ), (OT_NONE, OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_BITS8,OT_BITS8,OT_BITS16,OT_BITS8,OT_BITS16,OT_BITS32, @@ -429,7 +458,8 @@ implementation OT_BITS64, OT_NEAR,OT_FAR,OT_SHORT, OT_NONE, - OT_NONE + OT_BITS128, + OT_BITS256 ), (OT_NONE, OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_NONE,OT_NONE,OT_NONE,OT_NONE,OT_NONE,OT_NONE, @@ -438,7 +468,8 @@ implementation OT_BITS64, OT_NEAR,OT_FAR,OT_SHORT, OT_NONE, - OT_NONE + OT_BITS128, + OT_BITS256 ) ); @@ -455,7 +486,8 @@ implementation OT_BITS64, OT_NEAR,OT_FAR,OT_SHORT, OT_NONE, - OT_NONE + OT_BITS128, + OT_BITS256 ), (OT_NONE, OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_BITS8,OT_BITS8,OT_BITS16, @@ -464,7 +496,8 @@ implementation OT_BITS64, OT_NEAR,OT_FAR,OT_SHORT, OT_NONE, - OT_NONE + OT_BITS128, + OT_BITS256 ), (OT_NONE, OT_BITS8,OT_BITS16,OT_BITS32,OT_BITS64,OT_NONE,OT_NONE,OT_NONE, @@ -473,7 +506,8 @@ implementation OT_BITS64, OT_NEAR,OT_FAR,OT_SHORT, OT_NONE, - OT_NONE + OT_BITS128, + OT_BITS256 ) ); @@ -482,6 +516,11 @@ implementation ); {$endif x86_64} + function MemRefInfo(aAsmop: TAsmOp): TInsTabMemRefSizeInfoRec; + begin + result := InsTabMemRefSizeInfoCache^[aAsmop]; + end; + { Operation type for spilling code } type toperation_type_table=array[tasmop,0..Max_Operands] of topertype; @@ -808,6 +847,9 @@ implementation if (ot and OT_XMMREG)=OT_XMMREG then s:=s+'xmmreg' else + if (ot and OT_YMMREG)=OT_YMMREG then + s:=s+'ymmreg' + else if (ot and OT_MMXREG)=OT_MMXREG then s:=s+'mmxreg' else @@ -848,6 +890,12 @@ implementation if (ot and OT_BITS64)<>0 then s:=s+'64' else + if (ot and OT_BITS128)<>0 then + s:=s+'128' + else + if (ot and OT_BITS256)<>0 then + s:=s+'256' + else s:=s+'??'; { signed } if (ot and OT_SIGNED)<>0 then @@ -1076,16 +1124,33 @@ implementation end; top_const : begin - { allow 2nd, 3rd or 4th operand being a constant and expect no size for shuf* etc. } - { further, allow AAD and AAM with imm. operand } - if (opsize=S_NO) and not((i in [1,2,3]) or ((i=0) and (opcode in [A_AAD,A_AAM]))) then - message(asmr_e_invalid_opcode_and_operand); - if (opsize<>S_W) and (aint(val)>=-128) and (val<=127) then - ot:=OT_IMM8 or OT_SIGNED + // if opcode is a SSE or AVX-instruction then we need a + // special handling (opsize can different from const-size) + // (e.g. "pextrw reg/m16, xmmreg, imm8" =>> opsize (16 bit), const-size (8 bit) + if (InsTabMemRefSizeInfoCache^[opcode].ExistsSSEAVX) and + (not(InsTabMemRefSizeInfoCache^[opcode].ConstSize in [csiMultiple, csiUnkown])) then + begin + case InsTabMemRefSizeInfoCache^[opcode].ConstSize of + csiNoSize: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE; + csiMem8: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS8; + csiMem16: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS16; + csiMem32: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS32; + csiMem64: ot := ot and (not(OT_SIZE_MASK)) or OT_IMMEDIATE or OT_BITS64; + end; + end else - ot:=OT_IMMEDIATE or opsize_2_type[i,opsize]; - if (val=1) and (i=1) then - ot := ot or OT_ONENESS; + begin + { allow 2nd, 3rd or 4th operand being a constant and expect no size for shuf* etc. } + { further, allow AAD and AAM with imm. operand } + if (opsize=S_NO) and not((i in [1,2,3]) or ((i=0) and (opcode in [A_AAD,A_AAM]))) then + message(asmr_e_invalid_opcode_and_operand); + if (opsize<>S_W) and (aint(val)>=-128) and (val<=127) then + ot:=OT_IMM8 or OT_SIGNED + else + ot:=OT_IMMEDIATE or opsize_2_type[i,opsize]; + if (val=1) and (i=1) then + ot := ot or OT_ONENESS; + end; end; top_none : begin @@ -1213,6 +1278,36 @@ implementation end; end; + if (InsTabMemRefSizeInfoCache^[opcode].MemRefSize = msiMultiple) and + (InsTabMemRefSizeInfoCache^[opcode].ExistsSSEAVX) then + begin + for i:=0 to p^.ops-1 do + begin + insot:=p^.optypes[i]; + if ((insot and OT_XMMRM) = OT_XMMRM) OR + ((insot and OT_YMMRM) = OT_YMMRM) then + begin + if (insot and OT_SIZE_MASK) = 0 then + begin + case insot and (OT_XMMRM or OT_YMMRM) of + OT_XMMRM: insot := insot or OT_BITS128; + OT_YMMRM: insot := insot or OT_BITS256; + end; + end; + end; + + currot:=oper[i]^.ot; + { Check the operand flags } + if (insot and (not currot) and OT_NON_SIZE)<>0 then + exit; + { Check if the passed operand size matches with one of + the supported operand sizes } + if ((insot and OT_SIZE_MASK)<>0) and + ((insot and currot and OT_SIZE_MASK)<>(currot and OT_SIZE_MASK)) then + exit; + end; + + end; result:=true; end; @@ -1732,12 +1827,22 @@ implementation c : byte; len : shortint; ea_data : ea; + exists_vex: boolean; + exists_vex_extention: boolean; + exists_prefix_66: boolean; + exists_prefix_F2: boolean; + exists_prefix_F3: boolean; {$ifdef x86_64} omit_rexw : boolean; {$endif x86_64} begin len:=0; codes:=@p^.code[0]; + exists_vex := false; + exists_vex_extention := false; + exists_prefix_66 := false; + exists_prefix_F2 := false; + exists_prefix_F3 := false; {$ifdef x86_64} rex:=0; omit_rexw:=false; @@ -1798,6 +1903,7 @@ implementation 56,57,58, 172,173,174 : inc(len,4); + 60,61,62,63: ; // ignore vex-coded operand-idx 208,209,210 : begin case (oper[c-208]^.ot and OT_SIZE_MASK) of @@ -1836,8 +1942,21 @@ implementation 213, 215, 217,218: ; - 219,220,241 : - inc(len); + 219: + begin + inc(len); + exists_prefix_F2 := true; + end; + 220: + begin + inc(len); + exists_prefix_F3 := true; + end; + 241: + begin + inc(len); + exists_prefix_66 := true; + end; 221: {$ifdef x86_64} omit_rexw:=true @@ -1864,6 +1983,38 @@ implementation {$endif x86_64} end; + 242: // VEX prefix for AVX (length = 2 or 3 bytes, dependens on REX.XBW or opcode-prefix ($0F38 or $0F3A)) + // =>> DEFAULT = 2 Bytes + begin + if not(exists_vex) then + begin + inc(len, 2); + exists_vex := true; + end; + end; + 243: // REX.W = 1 + // =>> VEX prefix length = 3 + begin + if not(exists_vex_extention) then + begin + inc(len); + exists_vex_extention := true; + end; + end; + 244: ; // VEX length bit + 247: inc(len); // operand 3 (ymmreg) encoded immediate byte (bit 4-7) + 248: // VEX-Extention prefix $0F + // ignore for calculating length + ; + 249, // VEX-Extention prefix $0F38 + 250: // VEX-Extention prefix $0F3A + begin + if not(exists_vex_extention) then + begin + inc(len); + exists_vex_extention := true; + end; + end; else InternalError(200603141); end; @@ -1879,9 +2030,24 @@ implementation else rex:=rex and $F7; end; - if rex<>0 then - Inc(len); + if not(exists_vex) then + begin + if rex<>0 then + Inc(len); + end; {$endif} + if exists_vex then + begin + if exists_prefix_66 then dec(len); + if exists_prefix_F2 then dec(len); + if exists_prefix_F3 then dec(len); + + {$ifdef x86_64} + if not(exists_vex_extention) then + if rex and $0B <> 0 then inc(len); // REX.WXB <> 0 =>> needed VEX-Extention + {$endif x86_64} + + end; calcsize:=len; end; @@ -1915,6 +2081,7 @@ implementation * \64, \65, \66 - select between \6[012] and \7[012] depending on 16/32 bit * assembly mode or the address-size override on the operand * \70, \71, \72 - a long relative operand, from operand 0, 1 or 2 + * \74, \75, \76 - a vex-coded vector operand, from operand 0, 1 or 2 * \1ab - a ModRM, calculated on EA in operand a, with the spare * field the register value of operand b. * \2ab - a ModRM, calculated on EA in operand a, with the spare @@ -1940,6 +2107,16 @@ implementation * \334 - 0xF2 prefix for SSE instructions * \335 - Indicates 64-bit operand size with REX.W not necessary * \361 - 0x66 prefix for SSE instructions + + * \362 - VEX prefix for AVX instructions + * \363 - VEX W1 + * \364 - VEX Vector length 256 + * \367 - operand 3 (ymmreg) encoded in bit 4-7 of the immediate byte + + * \370 - VEX 0F-FLAG + * \371 - VEX 0F38-FLAG + * \372 - VEX 0F3A-FLAG + } var @@ -2050,6 +2227,11 @@ implementation data,s,opidx : longint; ea_data : ea; relsym : TObjSymbol; + needed_VEX_Extention: boolean; + needed_VEX: boolean; + opmode: integer; + VEXvvvv: byte; + VEXmmmmm: byte; begin { safety check } if objdata.currobjsec.size<>longword(insoffset) then @@ -2062,10 +2244,129 @@ implementation { Force word push/pop for registers } if (opsize=S_W) and ((codes[0]=#4) or (codes[0]=#6) or ((codes[0]=#1) and ((codes[2]=#5) or (codes[2]=#7)))) then + begin + bytes[0]:=$66; + objdata.writebytes(bytes,1); + end; + + // needed VEX Prefix (for AVX etc.) + + needed_VEX := false; + needed_VEX_Extention := false; + opmode := -1; + VEXvvvv := 0; + VEXmmmmm := 0; + repeat + c:=ord(codes^); + inc(codes); + + case c of + 0: break; + 1, + 2, + 3: inc(codes,c); + 60: opmode := 0; + 61: opmode := 1; + 62: opmode := 2; + 219: VEXvvvv := VEXvvvv OR $02; // set SIMD-prefix $F3 + 220: VEXvvvv := VEXvvvv OR $03; // set SIMD-prefix $F2 + 241: VEXvvvv := VEXvvvv OR $01; // set SIMD-prefix $66 + 242: needed_VEX := true; + 243: begin + needed_VEX_Extention := true; + VEXvvvv := VEXvvvv OR (1 shl 7); // set REX.W + end; + 244: VEXvvvv := VEXvvvv OR $04; // vectorlength = 256 bits AND no scalar + 248: VEXmmmmm := VEXmmmmm OR $01; // set leading opcode byte $0F + 249: begin + needed_VEX_Extention := true; + VEXmmmmm := VEXmmmmm OR $02; // set leading opcode byte $0F38 + end; + 250: begin + needed_VEX_Extention := true; + VEXmmmmm := VEXmmmmm OR $03; // set leading opcode byte $0F3A + end; + + end; + until false; + + if needed_VEX then + begin + if (opmode > ops) or + (opmode < -1) then + begin + Internalerror(777100); + end + else if opmode = -1 then + begin + VEXvvvv := VEXvvvv or ($0F shl 3); // set VEXvvvv bits (bits 6-3) to 1 + end + else if oper[opmode]^.typ = top_reg then + begin + VEXvvvv := VEXvvvv or ((not(regval(oper[opmode]^.reg)) and $07) shl 3); + + {$ifdef x86_64} + if rexbits(oper[opmode]^.reg) = 0 then VEXvvvv := VEXvvvv or (1 shl 6); + {$else} + VEXvvvv := VEXvvvv or (1 shl 6); + {$endif x86_64} + end + else Internalerror(777101); + + if not(needed_VEX_Extention) then + begin + {$ifdef x86_64} + if rex and $0B <> 0 then needed_VEX_Extention := true; + {$endif x86_64} + end; + + if needed_VEX_Extention then + begin + // VEX-Prefix-Length = 3 Bytes + bytes[0]:=$C4; + objdata.writebytes(bytes,1); + + {$ifdef x86_64} + VEXmmmmm := VEXmmmmm or ((not(rex) and $07) shl 5); // set REX.rxb + {$else} + VEXmmmmm := VEXmmmmm or (7 shl 5); // + {$endif x86_64} + + bytes[0] := VEXmmmmm; + objdata.writebytes(bytes,1); + + {$ifdef x86_64} + VEXvvvv := VEXvvvv OR ((rex and $08) shl 7); // set REX.w + {$endif x86_64} + bytes[0] := VEXvvvv; + objdata.writebytes(bytes,1); + end + else begin - bytes[0]:=$66; + // VEX-Prefix-Length = 2 Bytes + bytes[0]:=$C5; + objdata.writebytes(bytes,1); + + {$ifdef x86_64} + if rex and $04 = 0 then + {$endif x86_64} + begin + VEXvvvv := VEXvvvv or (1 shl 7); + end; + + bytes[0] := VEXvvvv; objdata.writebytes(bytes,1); end; + end + else + begin + needed_VEX_Extention := false; + opmode := -1; + end; + + { load data to write } + codes:=insentry^.code; + repeat c:=ord(codes^); inc(codes); @@ -2075,7 +2376,8 @@ implementation 1,2,3 : begin {$ifdef x86_64} - maybewriterex; + if not(needed_VEX) then // TG + maybewriterex; {$endif x86_64} objdata.writebytes(codes^,c); inc(codes,c); @@ -2116,7 +2418,8 @@ implementation 8,9,10 : begin {$ifdef x86_64} - maybewriterex; + if not(needed_VEX) then // TG + maybewriterex; {$endif x86_64} bytes[0]:=ord(codes^)+regval(oper[c-8]^.reg); inc(codes); @@ -2248,6 +2551,8 @@ implementation else objdata_writereloc(currval-insend,4,nil,currabsreloc32) end; + 60,61,62 : ; // 074..076 - vex-coded vector operand + // ignore 172,173,174 : // 0254..0256 - dword implicitly sign-extended to 64-bit (x86_64 only) begin getvalsym(c-172); @@ -2298,10 +2603,14 @@ implementation 211, 213 : {no action needed}; - 212, 241 : + 212, + 241: begin - bytes[0]:=$66; - objdata.writebytes(bytes,1); + if not(needed_VEX) then + begin + bytes[0]:=$66; + objdata.writebytes(bytes,1); + end; end; 214 : begin @@ -2311,13 +2620,19 @@ implementation end; 219 : begin - bytes[0]:=$f3; - objdata.writebytes(bytes,1); + if not(needed_VEX) then + begin + bytes[0]:=$f3; + objdata.writebytes(bytes,1); + end; end; 220 : begin - bytes[0]:=$f2; - objdata.writebytes(bytes,1); + if not(needed_VEX) then + begin + bytes[0]:=$f2; + objdata.writebytes(bytes,1); + end; end; 221: ; @@ -2328,6 +2643,29 @@ implementation { these are dissambler hints or 32 bit prefixes which are not needed } end; + 242..244: ; // VEX flags =>> nothing todo + 247: begin + if needed_VEX then + begin + if ops = 4 then + begin + if (oper[3]^.typ=top_reg) then + begin + if (oper[3]^.ot and otf_reg_xmm <> 0) or + (oper[3]^.ot and otf_reg_ymm <> 0) then + begin + bytes[0] := ((getsupreg(oper[3]^.reg) and 15) shl 4); + objdata.writebytes(bytes,1); + end + else Internalerror(777102); + end + else Internalerror(777103); + end + else Internalerror(777104); + end + else Internalerror(777105); + end; + 248..250: ; // VEX flags =>> nothing todo 31, 48,49,50 : begin @@ -2337,8 +2675,9 @@ implementation begin { rex should be written at this point } {$ifdef x86_64} - if (rex<>0) and not(rexwritten) then - internalerror(200603191); + if not(needed_VEX) then // TG + if (rex<>0) and not(rexwritten) then + internalerror(200603191); {$endif x86_64} if (c>=64) and (c<=151) then // 0100..0227 begin @@ -2611,11 +2950,279 @@ implementation end; + procedure BuildInsTabMemRefSizeInfoCache; + var + AsmOp: TasmOp; + i,j: longint; + insentry : PInsEntry; + MRefInfo: TMemRefSizeInfo; + SConstInfo: TConstSizeInfo; + actRegSize: int64; + actMemSize: int64; + actConstSize: int64; + actRegCount: integer; + actMemCount: integer; + actConstCount: integer; + actRegTypes : int64; + actRegMemTypes: int64; + NewRegSize: int64; + NewMemSize: int64; + NewConstSize: int64; + RegSize: int64; + MemSize: int64; + ConstSize: int64; + RegMMXSizeMask: int64; + RegXMMSizeMask: int64; + RegYMMSizeMask: int64; + + bitcount: integer; + IsRegSizeMemSize: boolean; + ExistsRegMem: boolean; + s: string; + + function bitcnt(aValue: int64): integer; + var + i: integer; + begin + result := 0; + + for i := 0 to 63 do + begin + if (aValue mod 2) = 1 then + begin + inc(result); + end; + + aValue := aValue shr 1; + end; + end; + + begin + new(InsTabMemRefSizeInfoCache); + FillChar(InsTabMemRefSizeInfoCache^,sizeof(TInsTabMemRefSizeInfoCache),0); + + for AsmOp := low(TAsmOp) to high(TAsmOp) do + begin + i := InsTabCache^[AsmOp]; + + if i >= 0 then + begin + InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiUnkown; + InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := csiUnkown; + InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := false; + + RegSize := 0; + IsRegSizeMemSize := true; + ExistsRegMem := false; + + insentry:=@instab[i]; + RegMMXSizeMask := 0; + RegXMMSizeMask := 0; + RegYMMSizeMask := 0; + + while (insentry^.opcode=AsmOp) do + begin + MRefInfo := msiUnkown; + + actRegSize := 0; + actRegCount := 0; + actRegTypes := 0; + NewRegSize := 0; + + actMemSize := 0; + actMemCount := 0; + actRegMemTypes := 0; + NewMemSize := 0; + + actConstSize := 0; + actConstCount := 0; + NewConstSize := 0; + + + if asmop = a_movups then + begin + RegXMMSizeMask := RegXMMSizeMask; + end; + + + + for j := 0 to insentry^.ops -1 do + begin + if (insentry^.optypes[j] and OT_REGISTER) = OT_REGISTER then + begin + inc(actRegCount); + + NewRegSize := (insentry^.optypes[j] and OT_SIZE_MASK); + if NewRegSize = 0 then + begin + case insentry^.optypes[j] and (OT_MMXREG OR OT_XMMREG OR OT_YMMREG) of + OT_MMXREG: begin + NewRegSize := OT_BITS64; + end; + OT_XMMREG: begin + NewRegSize := OT_BITS128; + InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true; + end; + OT_YMMREG: begin + NewRegSize := OT_BITS256; + InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX := true; + end; + else NewRegSize := not(0); + end; + end; + + actRegSize := actRegSize or NewRegSize; + actRegTypes := actRegTypes or (insentry^.optypes[j] and (OT_MMXREG OR OT_XMMREG OR OT_YMMREG)); + end + else if ((insentry^.optypes[j] and OT_MEMORY) <> 0) then + begin + inc(actMemCount); + + actMemSize := actMemSize or (insentry^.optypes[j] and OT_SIZE_MASK); + if (insentry^.optypes[j] and OT_REGMEM) = OT_REGMEM then + begin + actRegMemTypes := actRegMemTypes or insentry^.optypes[j]; + end; + end + else if ((insentry^.optypes[j] and OT_IMMEDIATE) = OT_IMMEDIATE) then + begin + inc(actConstCount); + + actConstSize := actConstSize or (insentry^.optypes[j] and OT_SIZE_MASK); + end + end; + + if actConstCount > 0 then + begin + case actConstSize of + 0: SConstInfo := csiNoSize; + OT_BITS8: SConstInfo := csiMem8; + OT_BITS16: SConstInfo := csiMem16; + OT_BITS32: SConstInfo := csiMem32; + OT_BITS64: SConstInfo := csiMem64; + else SConstInfo := csiMultiple; + end; + + if InsTabMemRefSizeInfoCache^[AsmOp].ConstSize = csiUnkown then + begin + InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := SConstInfo; + end + else if InsTabMemRefSizeInfoCache^[AsmOp].ConstSize <> SConstInfo then + begin + InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := csiMultiple; + end; + end; + + + case actMemCount of + 0: ; // nothing todo + 1: begin + MRefInfo := msiUnkown; + case actRegMemTypes and (OT_MMXRM OR OT_XMMRM OR OT_YMMRM) of + OT_MMXRM: actMemSize := actMemSize or OT_BITS64; + OT_XMMRM: actMemSize := actMemSize or OT_BITS128; + OT_YMMRM: actMemSize := actMemSize or OT_BITS256; + end; + + case actMemSize of + 0: MRefInfo := msiNoSize; + OT_BITS8: MRefInfo := msiMem8; + OT_BITS16: MRefInfo := msiMem16; + OT_BITS32: MRefInfo := msiMem32; + OT_BITS64: MRefInfo := msiMem64; + OT_BITS128: MRefInfo := msiMem128; + OT_BITS256: MRefInfo := msiMem256; + OT_BITS80, + OT_FAR, + OT_NEAR, + OT_SHORT: ; // ignore + else begin + bitcount := bitcnt(actMemSize); + + if bitcount > 1 then MRefInfo := msiMultiple + else InternalError(777203); + end; + end; + + if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiUnkown then + begin + InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := MRefInfo; + end + else if InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize <> MRefInfo then + begin + InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMultiple; + end; + + if actRegCount > 0 then + begin + case actRegTypes and (OT_MMXREG or OT_XMMREG or OT_YMMREG) of + OT_MMXREG: RegMMXSizeMask := RegMMXSizeMask or actMemSize; + OT_XMMREG: RegXMMSizeMask := RegXMMSizeMask or actMemSize; + OT_YMMREG: RegYMMSizeMask := RegYMMSizeMask or actMemSize; + else begin + RegMMXSizeMask := not(0); + RegXMMSizeMask := not(0); + RegYMMSizeMask := not(0); + end; + end; + end; + end; + else InternalError(777202); + end; + + inc(insentry); + end; + + if (InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize = msiMultiple) and + (InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX)then + begin + case RegXMMSizeMask of + OT_BITS64: case RegYMMSizeMask of + OT_BITS128: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y128; + OT_BITS256: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y256; + end; + OT_BITS128: begin + if RegMMXSizeMask = 0 then + begin + case RegYMMSizeMask of + OT_BITS128: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegx64y128; + OT_BITS256: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegSize; + end; + end + else if RegYMMSizeMask = 0 then + begin + case RegMMXSizeMask of + OT_BITS64: InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiMemRegSize; + end; + end + else InternalError(777205); + end; + end; + end; + end; + end; + + for AsmOp := low(TAsmOp) to high(TAsmOp) do + begin + + + // only supported intructiones with SSE- or AVX-operands + if not(InsTabMemRefSizeInfoCache^[AsmOp].ExistsSSEAVX) then + begin + InsTabMemRefSizeInfoCache^[AsmOp].MemRefSize := msiUnkown; + InsTabMemRefSizeInfoCache^[AsmOp].ConstSize := csiUnkown; + end; + end; + end; + procedure InitAsm; begin build_spilling_operation_type_table; if not assigned(instabcache) then BuildInsTabCache; + + if not assigned(InsTabMemRefSizeInfoCache) then + BuildInsTabMemRefSizeInfoCache; end; @@ -2631,6 +3238,12 @@ implementation dispose(instabcache); instabcache:=nil; end; + + if assigned(InsTabMemRefSizeInfoCache) then + begin + dispose(InsTabMemRefSizeInfoCache); + InsTabMemRefSizeInfoCache:=nil; + end; end; diff --git a/compiler/x86/agx86att.pas b/compiler/x86/agx86att.pas index 57c48663e6..d38f61abc4 100644 --- a/compiler/x86/agx86att.pas +++ b/compiler/x86/agx86att.pas @@ -239,6 +239,7 @@ interface calljmp : boolean; need_second_mov : boolean; i : integer; + sreg : string; begin if hp.typ <> ait_instruction then exit; @@ -250,6 +251,28 @@ interface the fix consists of simply setting only the 4-byte register as the upper 4-bytes will be zeroed at the same time. } need_second_mov:=false; + + // BUGFIX GAS-assembler + // Intel "Intel 64 and IA-32 Architectures Software Developers manual 12/2011 + // Intel: VCVTDQ2PD YMMREG, YMMREG/mem128 ((intel syntax)) + // GAS: VCVTDQ2PD YMMREG, XMMREG/mem128 ((intel syntax)) + if (op = A_VCVTDQ2PD) and + (taicpu(hp).ops = 2) and + (taicpu(hp).oper[0]^.typ = top_reg) and + (taicpu(hp).oper[1]^.typ = top_reg) then + begin + if ((taicpu(hp).oper[0]^.ot and OT_YMMREG) = OT_YMMREG) and + ((taicpu(hp).oper[1]^.ot and OT_YMMREG) = OT_YMMREG) then + begin + // change registertype in oper[0] from OT_YMMREG to OT_XMMREG + taicpu(hp).oper[0]^.ot := taicpu(hp).oper[0]^.ot and not(OT_YMMREG) or OT_XMMREG; + + sreg := gas_regname(taicpu(hp).oper[0]^.reg); + if (copy(sreg, 1, 2) = '%y') or + (copy(sreg, 1, 2) = '%Y') then + taicpu(hp).oper[0]^.reg := gas_regnum_search('%x' + copy(sreg, 3, length(sreg) - 2)); + end; + end; {$ifdef x86_64} if (op=A_MOV) and (taicpu(hp).opsize=S_Q) and (taicpu(hp).oper[0]^.typ = top_const) then @@ -298,7 +321,38 @@ interface (taicpu(hp).oper[0]^.typ=top_reg) and (getregtype(taicpu(hp).oper[0]^.reg)=R_FPUREGISTER) ) then - owner.AsmWrite(gas_opsize2str[taicpu(hp).opsize]); + begin + if gas_needsuffix[op] = AttSufMM then + begin + for i:=0 to taicpu(hp).ops-1 do + begin + + if (taicpu(hp).oper[i]^.typ = top_ref) then + begin + case taicpu(hp).oper[i]^.ot and OT_SIZE_MASK of + OT_BITS32: begin + owner.AsmWrite(gas_opsize2str[S_L]); + break; + end; + OT_BITS64: begin + owner.AsmWrite(gas_opsize2str[S_Q]); + break; + end; + OT_BITS128: begin + owner.AsmWrite(gas_opsize2str[S_XMM]); + break; + end; + OT_BITS256: begin + owner.AsmWrite(gas_opsize2str[S_YMM]); + break; + end; + end; + end; + end; + end + else owner.AsmWrite(gas_opsize2str[taicpu(hp).opsize]); + end; + { process operands } if taicpu(hp).ops<>0 then begin diff --git a/compiler/x86/agx86int.pas b/compiler/x86/agx86int.pas index 05c9d3ab27..0783ad5e1e 100644 --- a/compiler/x86/agx86int.pas +++ b/compiler/x86/agx86int.pas @@ -336,6 +336,8 @@ implementation AsmWrite('dword ptr ') else AsmWrite('word ptr '); + S_XMM: AsmWrite('xmmword ptr '); + S_YMM: AsmWrite('ymmword ptr '); {$ifdef x86_64} S_BQ : if dest then AsmWrite('qword ptr ') @@ -349,7 +351,6 @@ implementation AsmWrite('qword ptr ') else AsmWrite('dword ptr '); - S_XMM: AsmWrite('xmmword ptr '); {$endif x86_64} end; diff --git a/compiler/x86/cgx86.pas b/compiler/x86/cgx86.pas index bfc10b51ed..ca168142de 100644 --- a/compiler/x86/cgx86.pas +++ b/compiler/x86/cgx86.pas @@ -134,16 +134,16 @@ unit cgx86; const {$ifdef x86_64} TCGSize2OpSize: Array[tcgsize] of topsize = - (S_NO,S_B,S_W,S_L,S_Q,S_T,S_B,S_W,S_L,S_Q,S_Q, + (S_NO,S_B,S_W,S_L,S_Q,S_XMM,S_B,S_W,S_L,S_Q,S_XMM, S_FS,S_FL,S_FX,S_IQ,S_FXX, - S_NO,S_NO,S_NO,S_MD,S_T, - S_NO,S_NO,S_NO,S_NO,S_T); + S_NO,S_NO,S_NO,S_MD,S_XMM,S_YMM, + S_NO,S_NO,S_NO,S_NO,S_XMM,S_YMM); {$else x86_64} TCGSize2OpSize: Array[tcgsize] of topsize = (S_NO,S_B,S_W,S_L,S_L,S_T,S_B,S_W,S_L,S_L,S_L, S_FS,S_FL,S_FX,S_IQ,S_FXX, - S_NO,S_NO,S_NO,S_MD,S_T, - S_NO,S_NO,S_NO,S_NO,S_T); + S_NO,S_NO,S_NO,S_MD,S_XMM,S_YMM, + S_NO,S_NO,S_NO,S_NO,S_XMM,S_YMM); {$endif x86_64} {$ifndef NOTARGETWIN} diff --git a/compiler/x86/cpubase.pas b/compiler/x86/cpubase.pas index 872c60348d..70a9e8ac49 100644 --- a/compiler/x86/cpubase.pas +++ b/compiler/x86/cpubase.pas @@ -52,7 +52,7 @@ uses {$endif x86_64} { This should define the array of instructions as string } - op2strtable=array[tasmop] of string[15]; + op2strtable=array[tasmop] of string[16]; const { First value of opcode enumeration } @@ -327,7 +327,9 @@ implementation internalerror(2009071902); end; OS_M128,OS_MS128: - cgsize2subreg:=R_SUBMMWHOLE; + cgsize2subreg:=R_SUBMMX; + OS_M256,OS_MS256: + cgsize2subreg:=R_SUBMMY; else internalerror(200301231); end; @@ -336,7 +338,7 @@ implementation function reg_cgsize(const reg: tregister): tcgsize; const subreg2cgsize:array[Tsubregister] of Tcgsize = - (OS_NO,OS_8,OS_8,OS_16,OS_32,OS_64,OS_NO,OS_NO,OS_NO,OS_F32,OS_F64,OS_M128); + (OS_NO,OS_8,OS_8,OS_16,OS_32,OS_64,OS_NO,OS_NO,OS_NO,OS_F32,OS_F64,OS_NO,OS_M128,OS_M256); begin case getregtype(reg) of R_INTREGISTER : @@ -367,7 +369,7 @@ implementation function reg2opsize(r:Tregister):topsize; const subreg2opsize : array[tsubregister] of topsize = - (S_NO,S_B,S_B,S_W,S_L,S_Q,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO); + (S_NO,S_B,S_B,S_W,S_L,S_Q,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO,S_NO); begin reg2opsize:=S_L; case getregtype(r) of @@ -458,7 +460,7 @@ implementation hr:=r; case getsubreg(hr) of R_SUBMMS,R_SUBMMD,R_SUBMMWHOLE: - setsubreg(hr,R_SUBNONE); + setsubreg(hr,R_SUBMMX); end; result:=findreg_by_number_table(hr,regnumber_index); end; diff --git a/compiler/x86/itcpugas.pas b/compiler/x86/itcpugas.pas index 4280245f4d..014101337e 100644 --- a/compiler/x86/itcpugas.pas +++ b/compiler/x86/itcpugas.pas @@ -29,7 +29,7 @@ interface cgbase,cpubase; type - TAttSuffix = (AttSufNONE,AttSufINT,AttSufFPU,AttSufFPUint,AttSufINTdual); + TAttSuffix = (AttSufNONE,AttSufINT,AttSufFPU,AttSufFPUint,AttSufINTdual,AttSufMM); const {$ifdef x86_64} @@ -50,7 +50,8 @@ interface 'd', '','','', 't', - '' + 'x', + 'y' ); { suffix-to-opsize conversion tables, used in asmreadrer } { !! S_LQ excluded: movzlq does not exist, movslq is processed @@ -76,7 +77,8 @@ interface 'd', '','','', 't', - '' + 'x', + 'y' ); { suffix-to-opsize conversion tables, used in asmreadrer } att_sizesuffixstr : array[0..9] of string[2] = ( diff --git a/compiler/x86/itx86int.pas b/compiler/x86/itx86int.pas index 182938678d..1199159576 100644 --- a/compiler/x86/itx86int.pas +++ b/compiler/x86/itx86int.pas @@ -58,20 +58,27 @@ implementation {$endif x86_64} - function findreg_by_intname(const s:string):byte; + function findreg_by_intname(const s:string):integer; var - i,p : tregisterindex; + i,p : integer; + s1: string; + + l,r,m: integer; begin {Binary search.} p:=0; - i:=regnumber_count_bsstart; - repeat - if (p+i<=high(tregisterindex)) and (int_regname_table[int_regname_index[p+i]]<=s) then - p:=p+i; - i:=i shr 1; - until i=0; - if int_regname_table[int_regname_index[p]]=s then - findreg_by_intname:=int_regname_index[p] + i := (high(tregisterindex) + 1) shr 1; + l := 0; + r := high(tregisterindex) + 1; + while l < r do + begin + m := (l + r) div 2; + if int_regname_table[int_regname_index[m]] < s then l := m + 1 + else r := m; + end; + + if int_regname_table[int_regname_index[r]]=s then + findreg_by_intname:=int_regname_index[r] else findreg_by_intname:=0; end; diff --git a/compiler/x86/rax86.pas b/compiler/x86/rax86.pas index c7042b053a..aa1c3ba7b0 100644 --- a/compiler/x86/rax86.pas +++ b/compiler/x86/rax86.pas @@ -88,7 +88,7 @@ uses globtype,globals,systems,verbose, procinfo, cpuinfo,cgbase,cgutils, - itcpugas,cgx86; + itcpugas,cgx86, symsym, cutils; {***************************************************************************** @@ -186,6 +186,13 @@ begin inherited SetSize(_size,force); { OS_64 will be set to S_L and be fixed later in SetCorrectSize } + + // multimedia register + case _size of + 16: size := OS_M128; + 32: size := OS_M256; + end; + opsize:=TCGSize2Opsize[size]; end; @@ -207,6 +214,16 @@ begin OS_64 : opsize:=S_IQ; end; end + else if gas_needsuffix[opcode]=AttSufMM then + begin + if (opr.typ=OPR_Reference) then + begin + case size of + OS_32 : size := OS_M32; + OS_64 : size := OS_M64; + end; + end; + end else begin if size=OS_64 then @@ -288,16 +305,299 @@ begin OpOrder:=op_intel; end; +const +{$ifdef x86_64} + topsize2memsize: array[topsize] of integer = + (0, 8,16,32,64,8,8,16,8,16,32, + 16,32,64, + 16,32,64,0,0, + 64, + 0,0,0, + 80, + 128, + 256 + ); +{$else} +topsize2memsize: array[topsize] of integer = + (0, 8,16,32,64,8,8,16, + 16,32,64, + 16,32,64,0,0, + 64, + 0,0,0, + 80, + 128, + 256 + ); +{$endif} procedure Tx86Instruction.AddReferenceSizes; { this will add the sizes for references like [esi] which do not have the size set yet, it will take only the size if the other operand is a register } var - operand2,i : longint; + operand2,i,j : longint; s : tasmsymbol; so : aint; + ExistsMemRefNoSize: boolean; + ExistsMemRef: boolean; + ExistsConstNoSize: boolean; + ExistsLocalSymSize: boolean; + memrefsize: integer; + memopsize: integer; + memoffset: asizeint; + s1: string; begin + ExistsMemRefNoSize := false; + ExistsMemRef := false; + ExistsConstNoSize := false; + ExistsLocalSymSize := false; + + for i := 1 to ops do + begin + if operands[i].Opr.Typ in [OPR_REFERENCE, OPR_LOCAL] then + begin + ExistsMemRef := true; + + if (tx86operand(operands[i]).opsize = S_NO) then + begin + ExistsMemRefNoSize := true; + + case operands[i].opr.Typ of + OPR_LOCAL: ExistsLocalSymSize := tx86operand(operands[i]).opr.localsym.getsize > 0; + OPR_REFERENCE: ExistsLocalSymSize := true; + end; + + end; + end + else if operands[i].Opr.Typ in [OPR_CONSTANT] then + begin + ExistsConstNoSize := tx86operand(operands[i]).opsize = S_NO; + end; + end; + + if (ExistsMemRef) and + (MemRefInfo(opcode).ExistsSSEAVX) then + begin + if (not(ExistsMemRefNoSize)) or + (ExistsLocalSymSize) then + begin + // - validate memory-reference-size + for i := 1 to ops do + begin + //if (operands[i].Opr.Typ in [OPR_REFERENCE, OPR_LOCAL]) and + // (tx86operand(operands[i]).opsize <> S_NO) then + if (operands[i].Opr.Typ in [OPR_REFERENCE, OPR_LOCAL]) then + begin + memrefsize := -1; + + case MemRefInfo(opcode).MemRefSize of + msiMem8: memrefsize := 8; + msiMem16: memrefsize := 16; + msiMem32: memrefsize := 32; + msiMem64: memrefsize := 64; + msiMem128: memrefsize := 128; + msiMem256: memrefsize := 256; + msiMemRegSize + : for j := 1 to ops do + begin + if operands[j].Opr.Typ = OPR_REGISTER then + begin + if (tx86operand(operands[j]).opsize <> S_NO) and + (tx86operand(operands[j]).size <> OS_NO) then + begin + case tx86operand(operands[j]).opsize of + S_B : memrefsize := 8; + S_W : memrefsize := 16; + S_L : memrefsize := 32; + S_Q : memrefsize := 64; + S_XMM : memrefsize := 128; + S_YMM : memrefsize := 256; + else Internalerror(777200); + end; + break; + end; + end; + end; + end; + + if memrefsize > -1 then + begin + memopsize := 0; + case operands[i].opr.typ of + OPR_LOCAL: memopsize := operands[i].opr.localvarsize * 8; + OPR_REFERENCE: memopsize := operands[i].opr.varsize * 8; + end; + + if memopsize = 0 then memopsize := topsize2memsize[tx86operand(operands[i]).opsize]; + + if (memopsize > 0) and + (memrefsize > 0) then + begin + memoffset := 0; + + case operands[i].opr.typ of + OPR_LOCAL: + memoffset := operands[i].opr.localconstoffset; + OPR_REFERENCE: + memoffset := operands[i].opr.constoffset; + end; + + if memoffset < 0 then + begin + Message2(asmr_w_check_mem_operand_negative_offset, + std_op2str[opcode], + ToStr(memoffset)); + end + else if (memopsize < (memrefsize + memoffset * 8)) then + begin + if memoffset = 0 then + begin + Message3(asmr_w_check_mem_operand_size3, + std_op2str[opcode], + ToStr(memopsize), + ToStr(memrefsize) + ); + end + else + begin + Message4(asmr_w_check_mem_operand_size_offset, + std_op2str[opcode], + ToStr(memopsize), + ToStr(memrefsize), + ToStr(memoffset) + ); + end; + end; + end; + end; + + + end; + end; + end; + end; + + if (ExistsMemRefNoSize or ExistsConstNoSize) and + (MemRefInfo(opcode).ExistsSSEAVX) then + begin + for i := 1 to ops do + begin + if (tx86operand(operands[i]).opsize = S_NO) then + begin + case operands[i].Opr.Typ of + OPR_REFERENCE: + case MemRefInfo(opcode).MemRefSize of + msiMem8: begin + tx86operand(operands[i]).opsize := S_B; + tx86operand(operands[i]).size := OS_8; + end; + msiMem16: begin + tx86operand(operands[i]).opsize := S_W; + tx86operand(operands[i]).size := OS_16; + end; + msiMem32: begin + tx86operand(operands[i]).opsize := S_L; + tx86operand(operands[i]).size := OS_32; + end; + msiMem64: begin + tx86operand(operands[i]).opsize := S_Q; + tx86operand(operands[i]).size := OS_M64; + end; + msiMem128: begin + tx86operand(operands[i]).opsize := S_XMM; + tx86operand(operands[i]).size := OS_M128; + end; + msiMem256: begin + tx86operand(operands[i]).opsize := S_YMM; + tx86operand(operands[i]).size := OS_M256; + opsize := S_YMM; + end; + msiMemRegSize: + begin + // mem-ref-size = register size + for j := 1 to ops do + begin + if operands[j].Opr.Typ = OPR_REGISTER then + begin + if (tx86operand(operands[j]).opsize <> S_NO) and + (tx86operand(operands[j]).size <> OS_NO) then + begin + tx86operand(operands[i]).opsize := tx86operand(operands[j]).opsize; + tx86operand(operands[i]).size := tx86operand(operands[j]).size; + break; + end + else Message(asmr_e_unable_to_determine_reference_size); + end; + end; + end; + msiMemRegx64y128: + begin + for j := 1 to ops do + begin + if operands[j].Opr.Typ = OPR_REGISTER then + begin + case getsubreg(operands[j].opr.reg) of + R_SUBMMX: begin + tx86operand(operands[i]).opsize := S_Q; + tx86operand(operands[i]).size := OS_M64; + break; + end; + R_SUBMMY: begin + tx86operand(operands[i]).opsize := S_XMM; + tx86operand(operands[i]).size := OS_M128; + break; + end; + else Message(asmr_e_unable_to_determine_reference_size); + end; + end; + end; + end; + msiMemRegx64y256: + begin + for j := 1 to ops do + begin + if operands[j].Opr.Typ = OPR_REGISTER then + begin + case getsubreg(operands[j].opr.reg) of + R_SUBMMX: begin + tx86operand(operands[i]).opsize := S_Q; + tx86operand(operands[i]).size := OS_M64; + break; + end; + R_SUBMMY: begin + tx86operand(operands[i]).opsize := S_YMM; + tx86operand(operands[i]).size := OS_M256; + break; + end; + else Message(asmr_e_unable_to_determine_reference_size); + end; + end; + end; + end; + msiNoSize: ; // all memory-sizes are ok + msiMultiple: Message(asmr_e_unable_to_determine_reference_size); // TODO individual message + end; + OPR_CONSTANT: + case MemRefInfo(opcode).ConstSize of + csiMem8: begin + tx86operand(operands[i]).opsize := S_B; + tx86operand(operands[i]).size := OS_8; + end; + csiMem16: begin + tx86operand(operands[i]).opsize := S_W; + tx86operand(operands[i]).size := OS_16; + end; + csiMem32: begin + tx86operand(operands[i]).opsize := S_L; + tx86operand(operands[i]).size := OS_32; + end; + end; + end; + end; + end; + end; + + for i:=1 to ops do begin operands[i].SetCorrectSize(opcode); @@ -327,8 +627,22 @@ begin begin if ((opcode<>A_MOVD) and (opcode<>A_CVTSI2SS)) then - tx86operand(operands[i]).opsize:=tx86operand(operands[operand2]).opsize; - end + begin + //tx86operand(operands[i]).opsize:=tx86operand(operands[operand2]).opsize; + + // torsten - 31.01.2012 + // old: xmm/ymm-register operands have a opsize = "S_NO" + // new: xmm/ymm-register operands have a opsize = "S_XMM/S_YMM" + + // any SSE- and AVX-opcodes have mixed operand sizes (e.g. cvtsd2ss xmmreg, xmmreg/m32) + // in this case is we need the old handling ("S_NO") + // =>> ignore + if (tx86operand(operands[operand2]).opsize <> S_XMM) and + (tx86operand(operands[operand2]).opsize <> S_YMM) then + tx86operand(operands[i]).opsize:=tx86operand(operands[operand2]).opsize + else tx86operand(operands[operand2]).opsize := S_NO; + end; + end else begin { if no register then take the opsize (which is available with ATT), @@ -436,8 +750,9 @@ begin opsize:=tx86operand(operands[2]).opsize; end; end; - 3 : - opsize:=tx86operand(operands[3]).opsize; + 3,4 : + opsize:=tx86operand(operands[ops]).opsize; + end; end; @@ -725,6 +1040,9 @@ begin (target_info.system in [system_i386_linux,system_i386_FreeBSD]) then Message(asmr_w_enter_not_supported_by_linux); + + + ai:=taicpu.op_none(opcode,siz); ai.fileinfo:=filepos; ai.SetOperandOrder(OpOrder); @@ -753,7 +1071,7 @@ begin asize:=OT_BITS8; OS_16,OS_S16 : asize:=OT_BITS16; - OS_32,OS_S32,OS_F32 : + OS_32,OS_S32,OS_F32,OS_M32 : asize:=OT_BITS32; OS_64,OS_S64: begin @@ -761,6 +1079,7 @@ begin integer operations it is seen as 32bit this applies only to i386, see tw16622} + if gas_needsuffix[opcode] in [attsufFPU,attsufFPUint] then asize:=OT_BITS64 {$ifdef i386} @@ -769,10 +1088,14 @@ begin {$endif i386} ; end; - OS_F64,OS_C64 : + OS_F64,OS_C64, OS_M64 : asize:=OT_BITS64; OS_F80 : asize:=OT_BITS80; + OS_128,OS_M128,OS_MS128: + asize := OT_BITS128; + OS_M256,OS_MS256: + asize := OT_BITS256; end; if asize<>0 then ai.oper[i-1]^.ot:=(ai.oper[i-1]^.ot and not OT_SIZE_MASK) or asize; diff --git a/compiler/x86/rax86att.pas b/compiler/x86/rax86att.pas index d9abc0f347..5427b3afb0 100644 --- a/compiler/x86/rax86att.pas +++ b/compiler/x86/rax86att.pas @@ -396,6 +396,12 @@ Implementation Message(asmr_e_wrong_sym_type); inc(l,toffset); oper.SetSize(tsize,true); + + case oper.opr.typ of + OPR_REFERENCE: oper.opr.varsize := tsize; + OPR_LOCAL: oper.opr.localvarsize := tsize; + end; + end; end; if actasmtoken in [AS_PLUS,AS_MINUS] then @@ -410,7 +416,8 @@ Implementation (oper.opr.localsym.owner.symtabletype=parasymtable) and (current_procinfo.procdef.proccalloption<>pocall_register) then Message(asmr_e_cannot_access_field_directly_for_parameters); - inc(oper.opr.localsymofs,l) + inc(oper.opr.localsymofs,l); + inc(oper.opr.localconstoffset,l); end; OPR_CONSTANT : if (mangledname<>'') then @@ -423,7 +430,10 @@ Implementation else inc(oper.opr.val,l); OPR_REFERENCE : - inc(oper.opr.ref.offset,l); + begin + inc(oper.opr.ref.offset,l); + inc(oper.opr.constoffset,l); + end; OPR_SYMBOL: Message(asmr_e_invalid_symbol_ref); else @@ -500,6 +510,11 @@ Implementation if (mangledname<>'') then Message(asmr_e_invalid_reference_syntax); inc(oper.opr.ref.offset,l); + + case oper.opr.typ of + OPR_REFERENCE: oper.opr.varsize := k; + OPR_LOCAL: oper.opr.localvarsize := k; + end; end; MaybeGetPICModifier(oper); case actasmtoken of @@ -656,9 +671,15 @@ Implementation OPR_CONSTANT : inc(oper.opr.val,l); OPR_LOCAL : - inc(oper.opr.localsymofs,l); + begin + inc(oper.opr.localsymofs,l); + inc(oper.opr.localconstoffset, l); + end; OPR_REFERENCE : - inc(oper.opr.ref.offset,l); + begin + inc(oper.opr.ref.offset,l); + inc(oper.opr.constoffset, l); + end; else internalerror(200309202); end; diff --git a/compiler/x86/rax86int.pas b/compiler/x86/rax86int.pas index 91a92753b0..56a7249645 100644 --- a/compiler/x86/rax86int.pas +++ b/compiler/x86/rax86int.pas @@ -42,7 +42,7 @@ Unit Rax86int; {------------------ Assembler directives --------------------} AS_ALIGN,AS_DB,AS_DW,AS_DD,AS_DQ,AS_END, {------------------ Assembler Operators --------------------} - AS_BYTE,AS_WORD,AS_DWORD,AS_QWORD,AS_TBYTE,AS_DQWORD,AS_NEAR,AS_FAR, + AS_BYTE,AS_WORD,AS_DWORD,AS_QWORD,AS_TBYTE,AS_DQWORD,AS_OWORD,AS_XMMWORD,AS_YWORD,AS_YMMWORD,AS_NEAR,AS_FAR, AS_HIGH,AS_LOW,AS_OFFSET,AS_SIZEOF,AS_VMTOFFSET,AS_SEG,AS_TYPE,AS_PTR,AS_MOD,AS_SHL,AS_SHR,AS_NOT, AS_AND,AS_OR,AS_XOR,AS_WRT,AS___GOTPCREL); @@ -114,13 +114,13 @@ Unit Rax86int; { problems with shl,shr,not,and,or and xor, they are } { context sensitive. } _asmoperators : array[0.._count_asmoperators] of tasmkeyword = ( - 'BYTE','WORD','DWORD','QWORD','TBYTE','DQWORD','NEAR','FAR','HIGH', + 'BYTE','WORD','DWORD','QWORD','TBYTE','DQWORD','OWORD','XMMWORD','YWORD','YMMWORD','NEAR','FAR','HIGH', 'LOW','OFFSET','SIZEOF','VMTOFFSET','SEG','TYPE','PTR','MOD','SHL','SHR','NOT','AND', 'OR','XOR','WRT','GOTPCREL'); token2str : array[tasmtoken] of string[10] = ( '','Label','LLabel','String','Integer', - ',','[',']','(', + ',',',',',',',',',','[',']','(', ')',':','.','+','-','*', ';','identifier','register','opcode','/', '','','','','','END', @@ -747,7 +747,7 @@ Unit Rax86int; while (actasmtoken=AS_DOT) do begin Consume(AS_DOT); - if actasmtoken in [AS_BYTE,AS_ID,AS_WORD,AS_DWORD,AS_QWORD,AS_REGISTER] then + if actasmtoken in [AS_BYTE,AS_ID,AS_WORD,AS_DWORD,AS_QWORD,AS_OWORD,AS_XMMWORD,AS_YWORD,AS_YMMWORD,AS_REGISTER] then begin s:=s+'.'+actasmpattern; consume(actasmtoken); @@ -1509,7 +1509,10 @@ Unit Rax86int; scale:=l; end else - Inc(oper.opr.ref.offset,l); + begin + Inc(oper.opr.ref.offset,l); + Inc(oper.opr.constoffset,l); + end; end; OPR_LOCAL : begin @@ -1627,12 +1630,18 @@ Unit Rax86int; (oper.opr.localsym.owner.symtabletype=parasymtable) and (current_procinfo.procdef.proccalloption<>pocall_register) then Message(asmr_e_cannot_access_field_directly_for_parameters); - inc(oper.opr.localsymofs,toffset) + inc(oper.opr.localsymofs,toffset); + + oper.opr.localvarsize := tsize; end; OPR_CONSTANT : inc(oper.opr.val,toffset); OPR_REFERENCE : - inc(oper.opr.ref.offset,toffset); + begin + inc(oper.opr.ref.offset,toffset); + oper.opr.varsize := tsize; + end; + OPR_NONE : begin if (hs <> '') then @@ -1693,9 +1702,18 @@ Unit Rax86int; end else {$endif x86_64} - inc(oper.opr.ref.offset,BuildRefConstExpression); + begin + l := BuildRefConstExpression; + inc(oper.opr.ref.offset,l); + inc(oper.opr.constoffset,l); + end; OPR_LOCAL : - inc(oper.opr.localsymofs,BuildConstExpression); + begin + l := BuildConstExpression; + inc(oper.opr.localsymofs,l); + inc(oper.opr.localconstoffset,l); + end; + OPR_NONE, OPR_CONSTANT : BuildConstantOperand(oper); @@ -1767,9 +1785,18 @@ Unit Rax86int; Begin case oper.opr.typ of OPR_REFERENCE : - inc(oper.opr.ref.offset,BuildRefConstExpression); + begin + l := BuildRefConstExpression; + inc(oper.opr.ref.offset,l); + inc(oper.opr.constoffset,l); + end; + OPR_LOCAL : - inc(oper.opr.localsymofs,BuildRefConstExpression); + begin + l := BuildRefConstExpression; + inc(oper.opr.localsymofs,l); + inc(oper.opr.localconstoffset,l); + end; OPR_NONE, OPR_CONSTANT : BuildConstantOperand(oper); @@ -1878,7 +1905,11 @@ Unit Rax86int; AS_WORD, AS_TBYTE, AS_DQWORD, - AS_QWORD : + AS_QWORD, + AS_OWORD, + AS_XMMWORD, + AS_YWORD, + AS_YMMWORD: begin { Type specifier } oper.hastype:=true; @@ -1890,6 +1921,10 @@ Unit Rax86int; AS_QWORD : oper.typesize:=8; AS_DQWORD : oper.typesize:=16; AS_TBYTE : oper.typesize:=10; + AS_OWORD, + AS_XMMWORD: oper.typesize:=16; + AS_YWORD, + AS_YMMWORD: oper.typesize:=32; else internalerror(2010061101); end; diff --git a/compiler/x86/x86ins.dat b/compiler/x86/x86ins.dat index 0192216535..d75d902c3a 100644 --- a/compiler/x86/x86ins.dat +++ b/compiler/x86/x86ins.dat @@ -10,6 +10,7 @@ ; arguments bytes flags ; + [NONE] (Ch_None, Ch_None, Ch_None) void void none @@ -1458,7 +1459,7 @@ void \326\1\x9D X86_64 [POR] (Ch_All, Ch_None, Ch_None) mmxreg,mmxrm \2\x0F\xEB\110 PENT,MMX,SM -xmmreg,xmmreg \361\2\x0F\xEB\110 WILLAMETTE,SSE2,SM +xmmreg,xmmrm \361\2\x0F\xEB\110 WILLAMETTE,SSE2,SM [PREFETCH,prefetchX] (Ch_All, Ch_None, Ch_None) @@ -2209,32 +2210,31 @@ xmmreg,xmmrm \2\x0F\x2F\110 KATMAI,SSE [CVTPI2PS] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,mem \331\2\x0F\x2A\110 KATMAI,SSE,MMX -xmmreg,mmxreg \331\2\x0F\x2A\110 KATMAI,SSE,MMX +xmmreg,mmxrm \331\2\x0F\x2A\110 KATMAI,SSE,MMX [CVTPS2PI] (Ch_Wop2, Ch_Rop1, Ch_None) -mmxreg,mem \331\2\x0F\x2D\110 KATMAI,SSE,MMX +mmxreg,mem64 \331\2\x0F\x2D\110 KATMAI,SSE,MMX mmxreg,xmmreg \331\2\x0F\x2D\110 KATMAI,SSE,MMX -[CVTSI2SS,cvtsi2ssX] +[CVTSI2SS,cvtsi2ssM] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,mem \333\321\2\x0F\x2A\110 KATMAI,SSE -xmmreg,reg32|64 \333\321\2\x0F\x2A\110 KATMAI,SSE +xmmreg,rm32 \333\321\2\x0F\x2A\110 KATMAI,SSE +xmmreg,rm64 \333\321\2\x0F\x2A\110 KATMAI,SSE,X86_64 [CVTSS2SI,cvtss2siX] (Ch_Wop2, Ch_Rop1, Ch_None) -reg32|64,mem \333\320\2\x0F\x2D\110 KATMAI,SSE +reg32|64,mem32 \333\320\2\x0F\x2D\110 KATMAI,SSE reg32|64,xmmreg \333\320\2\x0F\x2D\110 KATMAI,SSE [CVTTPS2PI] (Ch_Wop2, Ch_Rop1, Ch_None) -mmxreg,mem \331\2\x0F\x2C\110 KATMAI,SSE,MMX +mmxreg,mem64 \331\2\x0F\x2C\110 KATMAI,SSE,MMX mmxreg,xmmreg \331\2\x0F\x2C\110 KATMAI,SSE,MMX [CVTTSS2SI,cvttss2siX] (Ch_Wop2, Ch_Rop1, Ch_None) -reg32|64,mem \333\320\2\x0F\x2C\110 KATMAI,SSE +reg32|64,mem32 \333\320\2\x0F\x2C\110 KATMAI,SSE reg32|64,xmmreg \333\320\2\x0F\x2C\110 KATMAI,SSE [DIVPS] @@ -2710,7 +2710,8 @@ xmmreg,xmmrm \361\2\x0F\x2F\110 WILLAMETTE,SSE2 [CVTDQ2PD] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,xmmrm \333\2\x0F\xE6\110 WILLAMETTE,SSE2 +xmmreg,xmmreg \333\2\x0F\xE6\110 WILLAMETTE,SSE2 +xmmreg,mem64 \333\2\x0F\xE6\110 WILLAMETTE,SSE2 [CVTDQ2PS] (Ch_Wop2, Ch_Rop1, Ch_None) @@ -2738,30 +2739,34 @@ xmmreg,xmmrm \361\2\x0F\x5B\110 WILLAMETTE,SSE2,SM [CVTPS2PD] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,xmmrm \2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SQ +xmmreg,xmmreg \2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SQ +xmmreg,mem64 \2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SQ [CVTSD2SI,cvtsd2siX] (Ch_Wop2, Ch_Rop1, Ch_None) -reg32|64,xmmreg \334\320\2\x0F\x2D\110 WILLAMETTE,SSE2 -reg32|64,mem \334\320\2\x0F\x2D\110 WILLAMETTE,SSE2 +reg32,xmmreg \334\2\x0F\x2D\110 WILLAMETTE,SSE2 +reg32,mem64 \334\2\x0F\x2D\110 WILLAMETTE,SSE2 +reg64,xmmreg \334\320\2\x0F\x2D\110 WILLAMETTE,SSE2,X86_64 +reg64,mem64 \334\320\2\x0F\x2D\110 WILLAMETTE,SSE2,X86_64 [CVTSD2SS] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,xmmrm \334\2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SQ +xmmreg,xmmreg \334\2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SQ +xmmreg,mem64 \334\2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SQ -[CVTSI2SD,cvtsi2sdX] +[CVTSI2SD,cvtsi2sdM] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,reg32|64 \334\321\2\x0F\x2A\110 WILLAMETTE,SSE2 -xmmreg,mem \334\321\2\x0F\x2A\110 WILLAMETTE,SSE2 +xmmreg,rm32 \334\2\x0F\x2A\110 WILLAMETTE,SSE2 +xmmreg,rm64 \326\334\321\2\x0F\x2A\110 WILLAMETTE,SSE2,X86_64 [CVTSS2SD] (Ch_Wop2, Ch_Rop1, Ch_None) -xmmreg,xmmrm \333\2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SD +xmmreg,xmmreg \333\2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SD +xmmreg,mem32 \333\2\x0F\x5A\110 WILLAMETTE,SSE2 ;,SD [CVTTPD2PI] (Ch_Wop2, Ch_Rop1, Ch_None) -mmxreg,xmmreg \361\2\x0F\x2C\110 WILLAMETTE,SSE2 -mmxreg,mem \361\2\x0F\x2C\110 WILLAMETTE,SSE2 +mmxreg,xmmrm \361\2\x0F\x2C\110 WILLAMETTE,SSE2 [CVTTPD2DQ] (Ch_Wop2, Ch_Rop1, Ch_None) @@ -2774,7 +2779,7 @@ xmmreg,xmmrm \333\2\x0F\x5B\110 WILLAMETTE,SSE2,SM [CVTTSD2SI,cvttsd2siX] (Ch_Wop2, Ch_Rop1, Ch_None) reg32|64,xmmreg \334\320\2\x0F\x2C\110 WILLAMETTE,SSE2 -reg32|64,mem \334\320\2\x0F\x2C\110 WILLAMETTE,SSE2 +reg32|64,mem64 \334\320\2\x0F\x2C\110 WILLAMETTE,SSE2 [DIVPD] (Ch_Mop2, Ch_Rop1, Ch_None) @@ -3441,3 +3446,1230 @@ void \326\1\xAD X86_64 [CMPSQ] (Ch_All, Ch_None, Ch_None) void \326\1\xA7 X86_64 + +;******************************************************************************* +;****** AVX I ****************************************************************** +;******************************************************************************* + + +[VADDPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x58\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x58\75\120 AVX,SANDYBRIDGE + +[VADDPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x58\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x58\75\120 AVX,SANDYBRIDGE + +[VADDSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x58\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x58\75\120 AVX,SANDYBRIDGE + +[VADDSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x58\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x58\75\120 AVX,SANDYBRIDGE + +[VADDSUBPD] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmreg,ymmrm \361\362\364\370\1\xD0\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xD0\75\120 AVX,SANDYBRIDGE + +[VADDSUBPS] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmreg,ymmrm \334\362\364\370\1\xD0\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \334\362\370\1\xD0\75\120 AVX,SANDYBRIDGE + +[VAESDEC] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\xDE\75\120 AVX,SANDYBRIDGE + +[VAESDECLAST] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\xDF\75\120 AVX,SANDYBRIDGE + +[VAESENC] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\xDC\75\120 AVX,SANDYBRIDGE + +[VAESENCLAST] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\xDD\75\120 AVX,SANDYBRIDGE + +[VAESIMC] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\371\1\xDB\110 AVX,SANDYBRIDGE + +[VAESKEYGENASSIST] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \361\362\372\1\xDF\110\26 AVX,SANDYBRIDGE + +[VANDNPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x55\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x55\75\120 AVX,SANDYBRIDGE + +[VANDNPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x55\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x55\75\120 AVX,SANDYBRIDGE + +[VANDPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x54\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x54\75\120 AVX,SANDYBRIDGE + +[VANDPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x54\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x54\75\120 AVX,SANDYBRIDGE + +[VBLENDPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x0D\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \361\362\364\372\1\x0D\75\120\27 AVX,SANDYBRIDGE + +[VBLENDPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x0C\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \361\362\364\372\1\x0C\75\120\27 AVX,SANDYBRIDGE + +[VBLENDVPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,xmmreg \361\362\372\1\x4B\75\120\367 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,ymmreg \361\362\364\372\1\x4B\75\120\367 AVX,SANDYBRIDGE + +[VBLENDVPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,xmmreg \361\362\372\1\x4A\75\120\367 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,ymmreg \361\362\364\372\1\x4A\75\120\367 AVX,SANDYBRIDGE + +[VBROADCASTF128] +(Ch_All, Ch_None, Ch_None) +ymmreg,mem128 \361\362\364\371\1\x1A\110 AVX,SANDYBRIDGE + +[VBROADCASTSD] +(Ch_All, Ch_None, Ch_None) +ymmreg,mem64 \361\362\364\371\1\x19\110 AVX,SANDYBRIDGE + +[VBROADCASTSS] +(Ch_All, Ch_None, Ch_None) +ymmreg,mem32 \361\362\364\371\1\x18\110 AVX,SANDYBRIDGE +xmmreg,mem32 \361\362\371\1\x18\110 AVX,SANDYBRIDGE + +[VCMPPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\370\1\xC2\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \361\362\364\370\1\xC2\75\120\27 AVX,SANDYBRIDGE + +[VCMPPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \362\370\1\xC2\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \362\364\370\1\xC2\75\120\27 AVX,SANDYBRIDGE + +[VCMPSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64,imm8 \334\362\370\1\xC2\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg,imm8 \334\362\370\1\xC2\75\120\27 AVX,SANDYBRIDGE + +[VCMPSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64,imm8 \333\362\370\1\xC2\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg,imm8 \333\362\370\1\xC2\75\120\27 AVX,SANDYBRIDGE + +[VCOMISD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\370\1\x2F\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\370\1\x2F\110 AVX,SANDYBRIDGE + +[VCOMISS] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem32 \362\370\1\x2F\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \362\370\1\x2F\110 AVX,SANDYBRIDGE + +[VCVTDQ2PD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \333\362\370\1\xE6\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \333\362\370\1\xE6\110 AVX,SANDYBRIDGE +ymmreg,ymmreg \333\362\364\370\1\xE6\110 AVX,SANDYBRIDGE +ymmreg,mem128 \333\362\364\370\1\xE6\110 AVX,SANDYBRIDGE + +[VCVTDQ2PS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \362\370\1\x5B\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \362\364\370\1\x5B\110 AVX,SANDYBRIDGE + +[VCVTPD2DQ,vcvtpd2dqM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \334\362\370\1\xE6\110 AVX,SANDYBRIDGE +xmmreg,ymmrm \334\362\364\370\1\xE6\110 AVX,SANDYBRIDGE + +[VCVTPD2PS,vcvtpd2psM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\370\1\x5A\110 AVX,SANDYBRIDGE +xmmreg,ymmrm \361\362\364\370\1\x5A\110 AVX,SANDYBRIDGE + +[VCVTPS2DQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\370\1\x5B\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \361\362\364\370\1\x5B\110 AVX,SANDYBRIDGE + +[VCVTPS2PD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \362\370\1\x5A\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \362\370\1\x5A\110 AVX,SANDYBRIDGE +ymmreg,xmmrm \362\364\370\1\x5A\110 AVX,SANDYBRIDGE + +[VCVTSD2SI] +(Ch_All, Ch_None, Ch_None) +reg32,mem64 \334\362\370\1\x2D\110 AVX,SANDYBRIDGE +reg32,xmmreg \334\362\370\1\x2D\110 AVX,SANDYBRIDGE +reg64,mem64 \334\362\363\370\1\x2D\110 AVX,SANDYBRIDGE +reg64,xmmreg \334\362\363\370\1\x2D\110 AVX,SANDYBRIDGE + +[VCVTSD2SS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x5A\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x5A\75\120 AVX,SANDYBRIDGE + +[VCVTSI2SD,vcvtsi2sdM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,rm32 \334\362\370\1\x2A\75\120 AVX,SANDYBRIDGE,SD +xmmreg,xmmreg,rm64 \334\362\363\370\1\x2A\75\120 AVX,SANDYBRIDGE + +[VCVTSI2SS,vcvtsi2ssM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,rm32 \333\362\370\1\x2A\75\120 AVX,SANDYBRIDGE,SD +xmmreg,xmmreg,rm64 \333\362\363\370\1\x2A\75\120 AVX,SANDYBRIDGE + +[VCVTSS2SD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x5A\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x5A\75\120 AVX,SANDYBRIDGE + +[VCVTSS2SI] +(Ch_All, Ch_None, Ch_None) +reg32,mem32 \333\362\370\1\x2D\110 AVX,SANDYBRIDGE +reg32,xmmreg \333\362\370\1\x2D\110 AVX,SANDYBRIDGE +reg64,mem32 \333\362\363\370\1\x2D\110 AVX,SANDYBRIDGE +reg64,xmmreg \333\362\363\370\1\x2D\110 AVX,SANDYBRIDGE + +[VCVTTPD2DQ,vcvttpd2dqM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\370\1\xE6\110 AVX,SANDYBRIDGE +xmmreg,ymmrm \361\362\364\370\1\xE6\110 AVX,SANDYBRIDGE + +[VCVTTPS2DQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \333\362\370\1\x5B\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \333\362\364\370\1\x5B\110 AVX,SANDYBRIDGE + +[VCVTTSD2SI] +(Ch_All, Ch_None, Ch_None) +reg32,mem64 \334\362\370\1\x2C\110 AVX,SANDYBRIDGE +reg32,xmmreg \334\362\370\1\x2C\110 AVX,SANDYBRIDGE +reg64,mem64 \334\362\363\370\1\x2C\110 AVX,SANDYBRIDGE +reg64,xmmreg \334\362\363\370\1\x2C\110 AVX,SANDYBRIDGE + +[VCVTTSS2SI] +(Ch_All, Ch_None, Ch_None) +reg32,mem32 \333\362\370\1\x2C\110 AVX,SANDYBRIDGE +reg32,xmmreg \333\362\370\1\x2C\110 AVX,SANDYBRIDGE +reg64,mem32 \333\362\363\370\1\x2C\110 AVX,SANDYBRIDGE +reg64,xmmreg \333\362\363\370\1\x2C\110 AVX,SANDYBRIDGE + +[VDIVPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x5E\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x5E\75\120 AVX,SANDYBRIDGE + +[VDIVPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x5E\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x5E\75\120 AVX,SANDYBRIDGE + +[VDIVSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x5E\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x5E\75\120 AVX,SANDYBRIDGE + +[VDIVSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x5E\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x5E\75\120 AVX,SANDYBRIDGE + +[VDPPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x41\75\120\27 AVX,SANDYBRIDGE + +[VDPPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x40\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \361\362\364\372\1\x40\75\120\27 AVX,SANDYBRIDGE + +[VEXTRACTF128] +(Ch_All, Ch_None, Ch_None) +xmmrm,ymmreg,imm8 \361\362\364\372\1\x19\101\26 AVX,SANDYBRIDGE + +[VEXTRACTPS] +(Ch_All, Ch_None, Ch_None) +rm32,xmmreg,imm8 \361\362\372\1\x17\101\26 AVX,SANDYBRIDGE + +[VHADDPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x7C\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x7C\75\120 AVX,SANDYBRIDGE + +[VHADDPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \334\362\370\1\x7C\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \334\362\364\370\1\x7C\75\120 AVX,SANDYBRIDGE + +[VHSUBPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x7D\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x7D\75\120 AVX,SANDYBRIDGE + +[VHSUBPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \334\362\370\1\x7D\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \334\362\364\370\1\x7D\75\120 AVX,SANDYBRIDGE + +[VINSERTF128] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmreg,xmmrm,imm8 \361\362\364\372\1\x18\75\120\27 AVX,SANDYBRIDGE + +[VINSERTPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32,imm8 \361\362\372\1\x21\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg,imm8 \361\362\372\1\x21\75\120\27 AVX,SANDYBRIDGE + +[VLDDQU] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem128 \334\362\370\1\xF0\110 AVX,SANDYBRIDGE +ymmreg,mem256 \334\362\364\370\1\xF0\110 AVX,SANDYBRIDGE + +[VLDMXCSR] +(Ch_All, Ch_None, Ch_None) +mem32 \362\370\1\xAE\202 AVX,SANDYBRIDGE + +[VMASKMOVDQU] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg \361\362\370\1\xF7\110 AVX,SANDYBRIDGE + +[VMASKMOVPD] +(Ch_All, Ch_None, Ch_None) +mem256,ymmreg,ymmreg \361\362\364\371\1\x2F\75\102 AVX,SANDYBRIDGE +mem128,xmmreg,xmmreg \361\362\371\1\x2F\75\102 AVX,SANDYBRIDGE +ymmreg,ymmreg,mem256 \361\362\364\371\1\x2D\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem128 \361\362\371\1\x2D\75\120 AVX,SANDYBRIDGE + +[VMASKMOVPS] +(Ch_All, Ch_None, Ch_None) +mem256,ymmreg,ymmreg \361\362\364\371\1\x2E\75\102 AVX,SANDYBRIDGE +mem128,xmmreg,xmmreg \361\362\371\1\x2E\75\102 AVX,SANDYBRIDGE +ymmreg,ymmreg,mem256 \361\362\364\371\1\x2C\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem128 \361\362\371\1\x2C\75\120 AVX,SANDYBRIDGE + +[VMAXPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x5F\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x5F\75\120 AVX,SANDYBRIDGE + +[VMAXPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x5F\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x5F\75\120 AVX,SANDYBRIDGE + +[VMAXSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x5F\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x5F\75\120 AVX,SANDYBRIDGE + +[VMAXSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x5F\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x5F\75\120 AVX,SANDYBRIDGE + +[VMINPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x5D\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x5D\75\120 AVX,SANDYBRIDGE + +[VMINPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x5D\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x5D\75\120 AVX,SANDYBRIDGE + +[VMINSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x5D\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x5D\75\120 AVX,SANDYBRIDGE + +[VMINSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x5D\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x5D\75\120 AVX,SANDYBRIDGE + +[VMOVAPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\370\1\x28\110 AVX,SANDYBRIDGE +xmmrm,xmmreg \361\362\370\1\x29\101 AVX,SANDYBRIDGE +ymmreg,ymmrm \361\362\364\370\1\x28\110 AVX,SANDYBRIDGE +ymmrm,ymmreg \361\362\364\370\1\x29\101 AVX,SANDYBRIDGE + +[VMOVAPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \362\370\1\x28\110 AVX,SANDYBRIDGE +xmmrm,xmmreg \362\370\1\x29\101 AVX,SANDYBRIDGE +ymmreg,ymmrm \362\364\370\1\x28\110 AVX,SANDYBRIDGE +ymmrm,ymmreg \362\364\370\1\x29\101 AVX,SANDYBRIDGE + +[VMOVD] +(Ch_All, Ch_None, Ch_None) +xmmreg,rm32 \361\362\370\1\x6E\110 AVX,SANDYBRIDGE +rm32,xmmreg \361\362\370\1\x7E\101 AVX,SANDYBRIDGE + +[VMOVDDUP] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm \334\362\364\370\1\x12\110 AVX,SANDYBRIDGE +xmmreg,mem64 \334\362\370\1\x12\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \334\362\370\1\x12\110 AVX,SANDYBRIDGE + +[VMOVDQA] +(Ch_All, Ch_None, Ch_None) +ymmrm,ymmreg \361\362\364\370\1\x7F\101 AVX,SANDYBRIDGE +xmmreg,xmmrm \361\362\370\1\x6F\110 AVX,SANDYBRIDGE +xmmrm,xmmreg \361\362\370\1\x7F\101 AVX,SANDYBRIDGE +ymmreg,ymmrm \361\362\364\370\1\x6F\110 AVX,SANDYBRIDGE + +[VMOVDQU] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm \333\362\364\370\1\x6F\110 AVX,SANDYBRIDGE +xmmreg,xmmrm \333\362\370\1\x6F\110 AVX,SANDYBRIDGE +xmmrm,xmmreg \333\362\370\1\x7F\101 AVX,SANDYBRIDGE +ymmrm,ymmreg \333\362\364\370\1\x7F\101 AVX,SANDYBRIDGE + +[VMOVHLPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmreg \362\370\1\x12\75\120 AVX,SANDYBRIDGE + +[VMOVHPD] +(Ch_All, Ch_None, Ch_None) +mem64,xmmreg \361\362\370\1\x17\101 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem64 \361\362\370\1\x16\75\120 AVX,SANDYBRIDGE + +[VMOVHPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \362\370\1\x16\75\120 AVX,SANDYBRIDGE +mem64,xmmreg \362\370\1\x17\101 AVX,SANDYBRIDGE + +[VMOVLHPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmreg \362\370\1\x16\75\120 AVX,SANDYBRIDGE + +[VMOVLPD] +(Ch_All, Ch_None, Ch_None) +mem64,xmmreg \361\362\370\1\x13\101 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem64 \361\362\370\1\x12\75\120 AVX,SANDYBRIDGE + +[VMOVLPS] +(Ch_All, Ch_None, Ch_None) +mem64,xmmreg \362\370\1\x13\101 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem64 \362\370\1\x12\75\120 AVX,SANDYBRIDGE + +[VMOVMSKPD] +(Ch_All, Ch_None, Ch_None) +reg32,ymmreg \361\362\364\370\1\x50\110 AVX,SANDYBRIDGE +reg64,xmmreg \361\362\370\1\x50\110 AVX,SANDYBRIDGE +reg32,xmmreg \361\362\370\1\x50\110 AVX,SANDYBRIDGE +reg64,ymmreg \361\362\364\370\1\x50\110 AVX,SANDYBRIDGE + +[VMOVMSKPS] +(Ch_All, Ch_None, Ch_None) +reg32,ymmreg \362\364\370\1\x50\110 AVX,SANDYBRIDGE +reg64,xmmreg \362\370\1\x50\110 AVX,SANDYBRIDGE +reg32,xmmreg \362\370\1\x50\110 AVX,SANDYBRIDGE +reg64,ymmreg \362\364\370\1\x50\110 AVX,SANDYBRIDGE + +[VMOVNTDQ] +(Ch_All, Ch_None, Ch_None) +mem128,xmmreg \361\362\370\1\xE7\101 AVX,SANDYBRIDGE +mem256,ymmreg \361\362\364\370\1\xE7\101 AVX,SANDYBRIDGE + +[VMOVNTDQA] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem128 \361\362\371\1\x2A\110 AVX,SANDYBRIDGE + +[VMOVNTPD] +(Ch_All, Ch_None, Ch_None) +mem256,ymmreg \361\362\364\370\1\x2B\101 AVX,SANDYBRIDGE +mem128,xmmreg \361\362\370\1\x2B\101 AVX,SANDYBRIDGE + +[VMOVNTPS] +(Ch_All, Ch_None, Ch_None) +mem128,ymmreg \362\364\370\1\x2B\101 AVX,SANDYBRIDGE +mem128,xmmreg \362\370\1\x2B\101 AVX,SANDYBRIDGE + +[VMOVQ] +(Ch_All, Ch_None, Ch_None) +rm64,xmmreg \361\362\363\370\1\x7E\101 AVX,SANDYBRIDGE +xmmreg,rm64 \361\362\363\370\1\x6E\110 AVX,SANDYBRIDGE + +[VMOVSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmreg \334\362\370\1\x10\75\120 AVX,SANDYBRIDGE +xmmreg,mem64 \334\362\370\1\x10\110 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x11\75\102 AVX,SANDYBRIDGE +mem64,xmmreg \334\362\370\1\x11\101 AVX,SANDYBRIDGE + +[VMOVSHDUP] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \333\362\370\1\x16\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \333\362\364\370\1\x16\110 AVX,SANDYBRIDGE + +[VMOVSLDUP] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \333\362\370\1\x12\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \333\362\364\370\1\x12\110 AVX,SANDYBRIDGE + +[VMOVSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmreg \333\362\370\1\x10\75\120 AVX,SANDYBRIDGE +xmmreg,mem64 \333\362\370\1\x10\110 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x11\75\102 AVX,SANDYBRIDGE +mem64,xmmreg \333\362\370\1\x11\101 AVX,SANDYBRIDGE + +[VMOVUPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\370\1\x10\110 AVX,SANDYBRIDGE +xmmrm,xmmreg \361\362\370\1\x11\101 AVX,SANDYBRIDGE +ymmreg,ymmrm \361\362\364\370\1\x10\110 AVX,SANDYBRIDGE +ymmrm,ymmreg \361\362\364\370\1\x11\101 AVX,SANDYBRIDGE + +[VMOVUPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \362\370\1\x10\110 AVX,SANDYBRIDGE +xmmrm,xmmreg \362\370\1\x11\101 AVX,SANDYBRIDGE +ymmreg,ymmrm \362\364\370\1\x10\110 AVX,SANDYBRIDGE +ymmrm,ymmreg \362\364\370\1\x11\101 AVX,SANDYBRIDGE + +[VMPSADBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x42\75\120\27 AVX,SANDYBRIDGE + +[VMULPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x59\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x59\75\120 AVX,SANDYBRIDGE + +[VMULPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x59\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x59\75\120 AVX,SANDYBRIDGE + +[VMULSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x59\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x59\75\120 AVX,SANDYBRIDGE + +[VMULSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x59\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x59\75\120 AVX,SANDYBRIDGE + +[VORPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x56\75\120 AVX,SANDYBRIDGE + +[VORPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x56\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x56\75\120 AVX,SANDYBRIDGE + +[VPABSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\371\1\x1C\110 AVX,SANDYBRIDGE + +[VPABSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\371\1\x1E\110 AVX,SANDYBRIDGE + +[VPABSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\371\1\x1D\110 AVX,SANDYBRIDGE + +[VPACKSSDW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x6B\75\120 AVX,SANDYBRIDGE + +[VPACKSSWB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x63\75\120 AVX,SANDYBRIDGE + +[VPACKUSDW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x2B\75\120 AVX,SANDYBRIDGE + +[VPACKUSWB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x67\75\120 AVX,SANDYBRIDGE + +[VPADDB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xFC\75\120 AVX,SANDYBRIDGE + +[VPADDD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xFE\75\120 AVX,SANDYBRIDGE + +[VPADDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xD4\75\120 AVX,SANDYBRIDGE + +[VPADDSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xEC\75\120 AVX,SANDYBRIDGE + +[VPADDSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xED\75\120 AVX,SANDYBRIDGE + +[VPADDUSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xDC\75\120 AVX,SANDYBRIDGE + +[VPADDUSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xDD\75\120 AVX,SANDYBRIDGE + +[VPADDW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xFD\75\120 AVX,SANDYBRIDGE + +[VPALIGNR] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x0F\75\120\27 AVX,SANDYBRIDGE + +[VPAND] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xDB\75\120 AVX,SANDYBRIDGE + +[VPANDN] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xDF\75\120 AVX,SANDYBRIDGE + +[VPAVGB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xE0\75\120 AVX,SANDYBRIDGE + +[VPAVGW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xE3\75\120 AVX,SANDYBRIDGE + +[VPBLENDVB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,xmmreg \361\362\372\1\x4C\75\120\367 AVX,SANDYBRIDGE + +[VPBLENDW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x0E\75\120\27 AVX,SANDYBRIDGE + +[VPCLMULQDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\372\1\x44\75\120\27 AVX,SANDYBRIDGE + +[VPCMPEQB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x74\75\120 AVX,SANDYBRIDGE + +[VPCMPEQD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x76\75\120 AVX,SANDYBRIDGE + +[VPCMPEQQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x29\75\120 AVX,SANDYBRIDGE + +[VPCMPEQW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x75\75\120 AVX,SANDYBRIDGE + +[VPCMPESTRI] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \361\362\372\1\x61\110\26 AVX,SANDYBRIDGE + +[VPCMPESTRM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \361\362\372\1\x60\110\26 AVX,SANDYBRIDGE + +[VPCMPGTB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x64\75\120 AVX,SANDYBRIDGE + +[VPCMPGTD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x66\75\120 AVX,SANDYBRIDGE + +[VPCMPGTQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x37\75\120 AVX,SANDYBRIDGE + +[VPCMPGTW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x65\75\120 AVX,SANDYBRIDGE + +[VPCMPISTRI] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \361\362\372\1\x63\110\26 AVX,SANDYBRIDGE + +[VPCMPISTRM] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \361\362\372\1\x62\110\26 AVX,SANDYBRIDGE + +[VPERM2F128] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmreg,ymmrm,imm8 \361\362\364\372\1\x06\75\120\27 AVX,SANDYBRIDGE + +[VPERMILPD] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmreg,ymmrm \361\362\364\371\1\x0D\75\120 AVX,SANDYBRIDGE +xmmreg,xmmrm,imm8 \361\362\372\1\x05\110\26 AVX,SANDYBRIDGE +ymmreg,ymmrm,imm8 \361\362\364\372\1\x05\110\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\371\1\x0D\75\120 AVX,SANDYBRIDGE + +[VPERMILPS] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmreg,ymmrm \361\362\364\371\1\x0C\75\120 AVX,SANDYBRIDGE +xmmreg,xmmrm,imm8 \361\362\372\1\x04\110\26 AVX,SANDYBRIDGE +ymmreg,ymmrm,imm8 \361\362\364\372\1\x04\110\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\371\1\x0C\75\120 AVX,SANDYBRIDGE + +[VPEXTRB] +(Ch_All, Ch_None, Ch_None) +reg32,xmmreg,imm8 \361\362\372\1\x14\101\26 AVX,SANDYBRIDGE +reg64,xmmreg,imm8 \361\362\372\1\x14\101\26 AVX,SANDYBRIDGE +mem8,xmmreg,imm8 \361\362\372\1\x14\101\26 AVX,SANDYBRIDGE + +[VPEXTRD] +(Ch_All, Ch_None, Ch_None) +rm32,xmmreg,imm8 \361\362\372\1\x16\101\26 AVX,SANDYBRIDGE + +[VPEXTRQ] +(Ch_All, Ch_None, Ch_None) +rm64,xmmreg,imm8 \361\362\363\372\1\x16\101\26 AVX,SANDYBRIDGE + +[VPEXTRW] +(Ch_All, Ch_None, Ch_None) +reg32,xmmreg,imm8 \361\362\370\1\xC5\110\26 AVX,SANDYBRIDGE +reg64,xmmreg,imm8 \361\362\370\1\xC5\110\26 AVX,SANDYBRIDGE +reg32,xmmreg,imm8 \361\362\372\1\x15\101\26 AVX,SANDYBRIDGE +reg64,xmmreg,imm8 \361\362\372\1\x15\101\26 AVX,SANDYBRIDGE +mem16,xmmreg,imm8 \361\362\372\1\x15\101\26 AVX,SANDYBRIDGE + + +[VPHADDD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x02\75\120 AVX,SANDYBRIDGE + +[VPHADDSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x03\75\120 AVX,SANDYBRIDGE + +[VPHADDW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x01\75\120 AVX,SANDYBRIDGE + +[VPHMINPOSUW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\371\1\x41\110 AVX,SANDYBRIDGE + +[VPHSUBD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x06\75\120 AVX,SANDYBRIDGE + +[VPHSUBSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x07\75\120 AVX,SANDYBRIDGE + +[VPHSUBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x05\75\120 AVX,SANDYBRIDGE + +[VPINSRB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,reg32,imm8 \361\362\372\1\x20\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem8,imm8 \361\362\372\1\x20\75\120\27 AVX,SANDYBRIDGE + +[VPINSRD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,rm32,imm8 \361\362\372\1\x22\75\120\27 AVX,SANDYBRIDGE + +[VPINSRQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,rm64,imm8 \361\362\363\372\1\x22\75\120\27 AVX,SANDYBRIDGE + +[VPINSRW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,reg32,imm8 \361\362\370\1\xC4\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,mem16,imm8 \361\362\370\1\xC4\75\120\27 AVX,SANDYBRIDGE + +[VPMADDUBSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x04\75\120 AVX,SANDYBRIDGE + +[VPMADDWD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xF5\75\120 AVX,SANDYBRIDGE + +[VPMAXSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x3C\75\120 AVX,SANDYBRIDGE + +[VPMAXSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x3D\75\120 AVX,SANDYBRIDGE + +[VPMAXSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xEE\75\120 AVX,SANDYBRIDGE + +[VPMAXUB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xDE\75\120 AVX,SANDYBRIDGE + +[VPMAXUD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x3F\75\120 AVX,SANDYBRIDGE + +[VPMAXUW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x3E\75\120 AVX,SANDYBRIDGE + +[VPMINSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x38\75\120 AVX,SANDYBRIDGE + +[VPMINSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x39\75\120 AVX,SANDYBRIDGE + +[VPMINSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xEA\75\120 AVX,SANDYBRIDGE + +[VPMINUB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xDA\75\120 AVX,SANDYBRIDGE + +[VPMINUD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x3B\75\120 AVX,SANDYBRIDGE + +[VPMINUW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x3A\75\120 AVX,SANDYBRIDGE + +[VPMOVMSKB] +(Ch_All, Ch_None, Ch_None) +reg64,xmmreg \361\362\370\1\xD7\110 AVX,SANDYBRIDGE +reg32,xmmreg \361\362\370\1\xD7\110 AVX,SANDYBRIDGE + +[VPMOVSXBD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem32 \361\362\371\1\x21\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x21\110 AVX,SANDYBRIDGE + +[VPMOVSXBQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem16 \361\362\371\1\x22\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x22\110 AVX,SANDYBRIDGE + +[VPMOVSXBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\371\1\x20\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x20\110 AVX,SANDYBRIDGE + +[VPMOVSXDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\371\1\x25\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x25\110 AVX,SANDYBRIDGE + +[VPMOVSXWD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\371\1\x23\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x23\110 AVX,SANDYBRIDGE + +[VPMOVSXWQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem32 \361\362\371\1\x24\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x24\110 AVX,SANDYBRIDGE + +[VPMOVZXBD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem32 \361\362\371\1\x31\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x31\110 AVX,SANDYBRIDGE + +[VPMOVZXBQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem16 \361\362\371\1\x32\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x32\110 AVX,SANDYBRIDGE + +[VPMOVZXBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\371\1\x30\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x30\110 AVX,SANDYBRIDGE + +[VPMOVZXDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\371\1\x35\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x35\110 AVX,SANDYBRIDGE + +[VPMOVZXWD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\371\1\x33\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x33\110 AVX,SANDYBRIDGE + +[VPMOVZXWQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem32 \361\362\371\1\x34\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\371\1\x34\110 AVX,SANDYBRIDGE + +[VPMULDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x28\75\120 AVX,SANDYBRIDGE + +[VPMULHRSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x0B\75\120 AVX,SANDYBRIDGE + +[VPMULHUW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xE4\75\120 AVX,SANDYBRIDGE + +[VPMULHW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xE5\75\120 AVX,SANDYBRIDGE + +[VPMULLD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x40\75\120 AVX,SANDYBRIDGE + +[VPMULLW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xD5\75\120 AVX,SANDYBRIDGE + +[VPMULUDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xF4\75\120 AVX,SANDYBRIDGE + +[VPOR] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xEB\75\120 AVX,SANDYBRIDGE + +[VPSADBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xF6\75\120 AVX,SANDYBRIDGE + +[VPSHUFB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x00\75\120 AVX,SANDYBRIDGE + +[VPSHUFD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \361\362\370\1\x70\110\26 AVX,SANDYBRIDGE + +[VPSHUFHW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \333\362\370\1\x70\110\26 AVX,SANDYBRIDGE + +[VPSHUFLW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm,imm8 \334\362\370\1\x70\110\26 AVX,SANDYBRIDGE + +[VPSIGNB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x08\75\120 AVX,SANDYBRIDGE + +[VPSIGND] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x0A\75\120 AVX,SANDYBRIDGE + +[VPSIGNW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\371\1\x09\75\120 AVX,SANDYBRIDGE + +[VPSLLD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x72\74\216\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xF2\75\120 AVX,SANDYBRIDGE + +[VPSLLDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x73\74\217\26 AVX,SANDYBRIDGE + +[VPSLLQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xF3\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,imm8 \361\362\370\1\x73\74\216\26 AVX,SANDYBRIDGE + +[VPSLLW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x71\74\216\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xF1\75\120 AVX,SANDYBRIDGE + +[VPSRAD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x72\74\214\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xE2\75\120 AVX,SANDYBRIDGE + +[VPSRAW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x71\74\214\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xE1\75\120 AVX,SANDYBRIDGE + +[VPSRLD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x72\74\212\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xD2\75\120 AVX,SANDYBRIDGE + +[VPSRLDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x73\74\213\26 AVX,SANDYBRIDGE + +[VPSRLQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x73\74\212\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xD3\75\120 AVX,SANDYBRIDGE + +[VPSRLW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,imm8 \361\362\370\1\x71\74\212\26 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmrm \361\362\370\1\xD1\75\120 AVX,SANDYBRIDGE + +[VPSUBB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xF8\75\120 AVX,SANDYBRIDGE + +[VPSUBD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xFA\75\120 AVX,SANDYBRIDGE + +[VPSUBQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xFB\75\120 AVX,SANDYBRIDGE + +[VPSUBSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xE8\75\120 AVX,SANDYBRIDGE + +[VPSUBSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xE9\75\120 AVX,SANDYBRIDGE + +[VPSUBUSB] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xD8\75\120 AVX,SANDYBRIDGE + +[VPSUBUSW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xD9\75\120 AVX,SANDYBRIDGE + +[VPSUBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xF9\75\120 AVX,SANDYBRIDGE + +[VPTEST] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm \361\362\364\371\1\x17\110 AVX,SANDYBRIDGE +xmmreg,xmmrm \361\362\371\1\x17\110 AVX,SANDYBRIDGE + +[VPUNPCKHBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x68\75\120 AVX,SANDYBRIDGE + +[VPUNPCKHDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x6A\75\120 AVX,SANDYBRIDGE + +[VPUNPCKHQDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x6D\75\120 AVX,SANDYBRIDGE + +[VPUNPCKHWD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x69\75\120 AVX,SANDYBRIDGE + +[VPUNPCKLBW] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x60\75\120 AVX,SANDYBRIDGE + +[VPUNPCKLDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x62\75\120 AVX,SANDYBRIDGE + +[VPUNPCKLQDQ] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x6C\75\120 AVX,SANDYBRIDGE + +[VPUNPCKLWD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x61\75\120 AVX,SANDYBRIDGE + +[VPXOR] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\xEF\75\120 AVX,SANDYBRIDGE + +[VRCPPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \362\370\1\x53\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \362\364\370\1\x53\110 AVX,SANDYBRIDGE + +[VRCPSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x53\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x53\75\120 AVX,SANDYBRIDGE + +[VROUNDPD] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm,imm8 \361\362\364\372\1\x09\110\26 AVX,SANDYBRIDGE +xmmreg,xmmrm,imm8 \361\362\372\1\x09\110\26 AVX,SANDYBRIDGE + +[VROUNDPS] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm,imm8 \361\362\364\372\1\x08\110\26 AVX,SANDYBRIDGE +xmmreg,xmmrm,imm8 \361\362\372\1\x08\110\26 AVX,SANDYBRIDGE + +[VROUNDSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64,imm8 \361\362\372\1\x0B\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg,imm8 \361\362\372\1\x0B\75\120\27 AVX,SANDYBRIDGE + +[VROUNDSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32,imm8 \361\362\372\1\x0A\75\120\27 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg,imm8 \361\362\372\1\x0A\75\120\27 AVX,SANDYBRIDGE + +[VRSQRTPS] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm \362\364\370\1\x52\110 AVX,SANDYBRIDGE +xmmreg,xmmrm \362\370\1\x52\110 AVX,SANDYBRIDGE + +[VRSQRTSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x52\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x52\75\120 AVX,SANDYBRIDGE + +[VSHUFPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \361\362\370\1\xC6\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \361\362\364\370\1\xC6\75\120\27 AVX,SANDYBRIDGE + +[VSHUFPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm,imm8 \362\370\1\xC6\75\120\27 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm,imm8 \362\364\370\1\xC6\75\120\27 AVX,SANDYBRIDGE + +[VSQRTPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\370\1\x51\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \361\362\364\370\1\x51\110 AVX,SANDYBRIDGE + +[VSQRTPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \362\370\1\x51\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \362\364\370\1\x51\110 AVX,SANDYBRIDGE + +[VSQRTSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x51\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x51\75\120 AVX,SANDYBRIDGE + +[VSQRTSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x51\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x51\75\120 AVX,SANDYBRIDGE + +[VSTMXCSR] +(Ch_All, Ch_None, Ch_None) +mem32 \362\370\1\xAE\203 AVX,SANDYBRIDGE + +[VSUBPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x5C\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x5C\75\120 AVX,SANDYBRIDGE + +[VSUBPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x5C\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x5C\75\120 AVX,SANDYBRIDGE + +[VSUBSD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem64 \334\362\370\1\x5C\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \334\362\370\1\x5C\75\120 AVX,SANDYBRIDGE + +[VSUBSS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,mem32 \333\362\370\1\x5C\75\120 AVX,SANDYBRIDGE +xmmreg,xmmreg,xmmreg \333\362\370\1\x5C\75\120 AVX,SANDYBRIDGE + +[VTESTPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmrm \361\362\371\1\x0F\110 AVX,SANDYBRIDGE +ymmreg,ymmrm \361\362\364\371\1\x0F\110 AVX,SANDYBRIDGE + +[VTESTPS] +(Ch_All, Ch_None, Ch_None) +ymmreg,ymmrm \361\362\364\371\1\x0E\110 AVX,SANDYBRIDGE +xmmreg,xmmrm \361\362\371\1\x0E\110 AVX,SANDYBRIDGE + +[VUCOMISD] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem64 \361\362\370\1\x2E\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \361\362\370\1\x2E\110 AVX,SANDYBRIDGE + +[VUCOMISS] +(Ch_All, Ch_None, Ch_None) +xmmreg,mem32 \362\370\1\x2E\110 AVX,SANDYBRIDGE +xmmreg,xmmreg \362\370\1\x2E\110 AVX,SANDYBRIDGE + +[VUNPCKHPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x15\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x15\75\120 AVX,SANDYBRIDGE + +[VUNPCKHPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x15\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x15\75\120 AVX,SANDYBRIDGE + +[VUNPCKLPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x14\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x14\75\120 AVX,SANDYBRIDGE + +[VUNPCKLPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x14\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x14\75\120 AVX,SANDYBRIDGE + +[VXORPD] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \361\362\370\1\x57\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \361\362\364\370\1\x57\75\120 AVX,SANDYBRIDGE + +[VXORPS] +(Ch_All, Ch_None, Ch_None) +xmmreg,xmmreg,xmmrm \362\370\1\x57\75\120 AVX,SANDYBRIDGE +ymmreg,ymmreg,ymmrm \362\364\370\1\x57\75\120 AVX,SANDYBRIDGE + +[VZEROALL] +(Ch_All, Ch_None, Ch_None) +void \362\364\370\1\x77 AVX,SANDYBRIDGE + +[VZEROUPPER] +(Ch_All, Ch_None, Ch_None) +void \362\370\1\x77 AVX,SANDYBRIDGE diff --git a/compiler/x86/x86reg.dat b/compiler/x86/x86reg.dat index 807eb4c215..aa426d0e6e 100644 --- a/compiler/x86/x86reg.dat +++ b/compiler/x86/x86reg.dat @@ -123,19 +123,36 @@ NR_MM5,$03000005,mm5,%mm5,mm5,mm5,34,34,46,OT_MMXREG,5 NR_MM6,$03000006,mm6,%mm6,mm6,mm6,35,35,47,OT_MMXREG,6 NR_MM7,$03000007,mm7,%mm7,mm7,mm7,36,36,48,OT_MMXREG,7 -NR_XMM0,$04000000,xmm0,%xmm0,xmm0,xmm0,21,21,17,OT_XMMREG,0 -NR_XMM1,$04000001,xmm1,%xmm1,xmm1,xmm1,22,22,18,OT_XMMREG,1 -NR_XMM2,$04000002,xmm2,%xmm2,xmm2,xmm2,23,23,19,OT_XMMREG,2 -NR_XMM3,$04000003,xmm3,%xmm3,xmm3,xmm3,24,24,20,OT_XMMREG,3 -NR_XMM4,$04000004,xmm4,%xmm4,xmm4,xmm4,25,25,21,OT_XMMREG,4 -NR_XMM5,$04000005,xmm5,%xmm5,xmm5,xmm5,26,26,22,OT_XMMREG,5 -NR_XMM6,$04000006,xmm6,%xmm6,xmm6,xmm6,27,27,23,OT_XMMREG,6 -NR_XMM7,$04000007,xmm7,%xmm7,xmm7,xmm7,28,28,24,OT_XMMREG,7 -NR_XMM8,$04000008,xmm8,%xmm8,xmm8,xmm8,-1,-1,25,OT_XMMREG,0,64 -NR_XMM9,$04000009,xmm9,%xmm9,xmm9,xmm9,-1,-1,26,OT_XMMREG,1,64 -NR_XMM10,$0400000a,xmm10,%xmm10,xmm10,xmm10,-1,-1,27,OT_XMMREG,2,64 -NR_XMM11,$0400000b,xmm11,%xmm11,xmm11,xmm11,-1,-1,28,OT_XMMREG,3,64 -NR_XMM12,$0400000c,xmm12,%xmm12,xmm12,xmm12,-1,-1,29,OT_XMMREG,4,64 -NR_XMM13,$0400000d,xmm13,%xmm13,xmm13,xmm13,-1,-1,30,OT_XMMREG,5,64 -NR_XMM14,$0400000e,xmm14,%xmm14,xmm14,xmm14,-1,-1,31,OT_XMMREG,6,64 -NR_XMM15,$0400000f,xmm15,%xmm15,xmm15,xmm15,-1,-1,32,OT_XMMREG,7,64 +NR_XMM0,$040C0000,xmm0,%xmm0,xmm0,xmm0,21,21,17,OT_XMMREG,0 +NR_XMM1,$040C0001,xmm1,%xmm1,xmm1,xmm1,22,22,18,OT_XMMREG,1 +NR_XMM2,$040C0002,xmm2,%xmm2,xmm2,xmm2,23,23,19,OT_XMMREG,2 +NR_XMM3,$040C0003,xmm3,%xmm3,xmm3,xmm3,24,24,20,OT_XMMREG,3 +NR_XMM4,$040C0004,xmm4,%xmm4,xmm4,xmm4,25,25,21,OT_XMMREG,4 +NR_XMM5,$040C0005,xmm5,%xmm5,xmm5,xmm5,26,26,22,OT_XMMREG,5 +NR_XMM6,$040C0006,xmm6,%xmm6,xmm6,xmm6,27,27,23,OT_XMMREG,6 +NR_XMM7,$040C0007,xmm7,%xmm7,xmm7,xmm7,28,28,24,OT_XMMREG,7 +NR_XMM8,$040C0008,xmm8,%xmm8,xmm8,xmm8,-1,-1,25,OT_XMMREG,0,64 +NR_XMM9,$040C0009,xmm9,%xmm9,xmm9,xmm9,-1,-1,26,OT_XMMREG,1,64 +NR_XMM10,$040C000a,xmm10,%xmm10,xmm10,xmm10,-1,-1,27,OT_XMMREG,2,64 +NR_XMM11,$040C000b,xmm11,%xmm11,xmm11,xmm11,-1,-1,28,OT_XMMREG,3,64 +NR_XMM12,$040C000c,xmm12,%xmm12,xmm12,xmm12,-1,-1,29,OT_XMMREG,4,64 +NR_XMM13,$040C000d,xmm13,%xmm13,xmm13,xmm13,-1,-1,30,OT_XMMREG,5,64 +NR_XMM14,$040C000e,xmm14,%xmm14,xmm14,xmm14,-1,-1,31,OT_XMMREG,6,64 +NR_XMM15,$040C000f,xmm15,%xmm15,xmm15,xmm15,-1,-1,32,OT_XMMREG,7,64 + +NR_YMM0,$040D0000,ymm0,%ymm0,ymm0,ymm0,21,21,17,OT_YMMREG,0 +NR_YMM1,$040D0001,ymm1,%ymm1,ymm1,ymm1,22,22,18,OT_YMMREG,1 +NR_YMM2,$040D0002,ymm2,%ymm2,ymm2,ymm2,23,23,19,OT_YMMREG,2 +NR_YMM3,$040D0003,ymm3,%ymm3,ymm3,ymm3,24,24,20,OT_YMMREG,3 +NR_YMM4,$040D0004,ymm4,%ymm4,ymm4,ymm4,25,25,21,OT_YMMREG,4 +NR_YMM5,$040D0005,ymm5,%ymm5,ymm5,ymm5,26,26,22,OT_YMMREG,5 +NR_YMM6,$040D0006,ymm6,%ymm6,ymm6,ymm6,27,27,23,OT_YMMREG,6 +NR_YMM7,$040D0007,ymm7,%ymm7,ymm7,ymm7,28,28,24,OT_YMMREG,7 +NR_YMM8,$040D0008,ymm8,%ymm8,ymm8,ymm8,-1,-1,25,OT_YMMREG,0,64 +NR_YMM9,$040D0009,ymm9,%ymm9,ymm9,ymm9,-1,-1,26,OT_YMMREG,1,64 +NR_YMM10,$040D000a,ymm10,%ymm10,ymm10,ymm10,-1,-1,27,OT_YMMREG,2,64 +NR_YMM11,$040D000b,ymm11,%ymm11,ymm11,ymm11,-1,-1,28,OT_YMMREG,3,64 +NR_YMM12,$040D000c,ymm12,%ymm12,ymm12,ymm12,-1,-1,29,OT_YMMREG,4,64 +NR_YMM13,$040D000d,ymm13,%ymm13,ymm13,ymm13,-1,-1,30,OT_YMMREG,5,64 +NR_YMM14,$040D000e,ymm14,%ymm14,ymm14,ymm14,-1,-1,31,OT_YMMREG,6,64 +NR_YMM15,$040D000f,ymm15,%ymm15,ymm15,ymm15,-1,-1,32,OT_YMMREG,7,64 diff --git a/compiler/x86_64/cpubase.inc b/compiler/x86_64/cpubase.inc index 41c706bd57..8b8b0c2d3e 100644 --- a/compiler/x86_64/cpubase.inc +++ b/compiler/x86_64/cpubase.inc @@ -34,7 +34,8 @@ type S_MD, S_NEAR,S_FAR,S_SHORT, S_T, - S_XMM + S_XMM, + S_YMM ); {***************************************************************************** diff --git a/compiler/x86_64/r8664ari.inc b/compiler/x86_64/r8664ari.inc index 4776e4ac1c..0c2ba57fe9 100644 --- a/compiler/x86_64/r8664ari.inc +++ b/compiler/x86_64/r8664ari.inc @@ -124,4 +124,20 @@ 117, 118, 119, +126, +127, +136, +137, +138, +139, +140, +141, +128, +129, +130, +131, +132, +133, +134, +135, 0 diff --git a/compiler/x86_64/r8664att.inc b/compiler/x86_64/r8664att.inc index 61a5134bb9..15174227ba 100644 --- a/compiler/x86_64/r8664att.inc +++ b/compiler/x86_64/r8664att.inc @@ -124,4 +124,20 @@ '%xmm12', '%xmm13', '%xmm14', -'%xmm15' +'%xmm15', +'%ymm0', +'%ymm1', +'%ymm2', +'%ymm3', +'%ymm4', +'%ymm5', +'%ymm6', +'%ymm7', +'%ymm8', +'%ymm9', +'%ymm10', +'%ymm11', +'%ymm12', +'%ymm13', +'%ymm14', +'%ymm15' diff --git a/compiler/x86_64/r8664con.inc b/compiler/x86_64/r8664con.inc index 9a21e16f85..360887252b 100644 --- a/compiler/x86_64/r8664con.inc +++ b/compiler/x86_64/r8664con.inc @@ -109,19 +109,35 @@ NR_MM4 = tregister($03000004); NR_MM5 = tregister($03000005); NR_MM6 = tregister($03000006); NR_MM7 = tregister($03000007); -NR_XMM0 = tregister($04000000); -NR_XMM1 = tregister($04000001); -NR_XMM2 = tregister($04000002); -NR_XMM3 = tregister($04000003); -NR_XMM4 = tregister($04000004); -NR_XMM5 = tregister($04000005); -NR_XMM6 = tregister($04000006); -NR_XMM7 = tregister($04000007); -NR_XMM8 = tregister($04000008); -NR_XMM9 = tregister($04000009); -NR_XMM10 = tregister($0400000a); -NR_XMM11 = tregister($0400000b); -NR_XMM12 = tregister($0400000c); -NR_XMM13 = tregister($0400000d); -NR_XMM14 = tregister($0400000e); -NR_XMM15 = tregister($0400000f); +NR_XMM0 = tregister($040C0000); +NR_XMM1 = tregister($040C0001); +NR_XMM2 = tregister($040C0002); +NR_XMM3 = tregister($040C0003); +NR_XMM4 = tregister($040C0004); +NR_XMM5 = tregister($040C0005); +NR_XMM6 = tregister($040C0006); +NR_XMM7 = tregister($040C0007); +NR_XMM8 = tregister($040C0008); +NR_XMM9 = tregister($040C0009); +NR_XMM10 = tregister($040C000a); +NR_XMM11 = tregister($040C000b); +NR_XMM12 = tregister($040C000c); +NR_XMM13 = tregister($040C000d); +NR_XMM14 = tregister($040C000e); +NR_XMM15 = tregister($040C000f); +NR_YMM0 = tregister($040D0000); +NR_YMM1 = tregister($040D0001); +NR_YMM2 = tregister($040D0002); +NR_YMM3 = tregister($040D0003); +NR_YMM4 = tregister($040D0004); +NR_YMM5 = tregister($040D0005); +NR_YMM6 = tregister($040D0006); +NR_YMM7 = tregister($040D0007); +NR_YMM8 = tregister($040D0008); +NR_YMM9 = tregister($040D0009); +NR_YMM10 = tregister($040D000a); +NR_YMM11 = tregister($040D000b); +NR_YMM12 = tregister($040D000c); +NR_YMM13 = tregister($040D000d); +NR_YMM14 = tregister($040D000e); +NR_YMM15 = tregister($040D000f); diff --git a/compiler/x86_64/r8664dwrf.inc b/compiler/x86_64/r8664dwrf.inc index 4cd671016f..a5abff273c 100644 --- a/compiler/x86_64/r8664dwrf.inc +++ b/compiler/x86_64/r8664dwrf.inc @@ -124,4 +124,20 @@ 29, 30, 31, +32, +17, +18, +19, +20, +21, +22, +23, +24, +25, +26, +27, +28, +29, +30, +31, 32 diff --git a/compiler/x86_64/r8664int.inc b/compiler/x86_64/r8664int.inc index e00c911af5..15cd8cbe8c 100644 --- a/compiler/x86_64/r8664int.inc +++ b/compiler/x86_64/r8664int.inc @@ -124,4 +124,20 @@ 'xmm12', 'xmm13', 'xmm14', -'xmm15' +'xmm15', +'ymm0', +'ymm1', +'ymm2', +'ymm3', +'ymm4', +'ymm5', +'ymm6', +'ymm7', +'ymm8', +'ymm9', +'ymm10', +'ymm11', +'ymm12', +'ymm13', +'ymm14', +'ymm15' diff --git a/compiler/x86_64/r8664iri.inc b/compiler/x86_64/r8664iri.inc index 35409c3e26..2cb03299ab 100644 --- a/compiler/x86_64/r8664iri.inc +++ b/compiler/x86_64/r8664iri.inc @@ -124,4 +124,20 @@ 116, 117, 118, -119 +119, +126, +127, +136, +137, +138, +139, +140, +141, +128, +129, +130, +131, +132, +133, +134, +135 diff --git a/compiler/x86_64/r8664nor.inc b/compiler/x86_64/r8664nor.inc index a267bd4b5c..d0c8805f4c 100644 --- a/compiler/x86_64/r8664nor.inc +++ b/compiler/x86_64/r8664nor.inc @@ -1,2 +1,2 @@ { don't edit, this file is generated from x86reg.dat } -126 +142 diff --git a/compiler/x86_64/r8664num.inc b/compiler/x86_64/r8664num.inc index e70b97dc41..fe2b5e632b 100644 --- a/compiler/x86_64/r8664num.inc +++ b/compiler/x86_64/r8664num.inc @@ -109,19 +109,35 @@ tregister($03000004), tregister($03000005), tregister($03000006), tregister($03000007), -tregister($04000000), -tregister($04000001), -tregister($04000002), -tregister($04000003), -tregister($04000004), -tregister($04000005), -tregister($04000006), -tregister($04000007), -tregister($04000008), -tregister($04000009), -tregister($0400000a), -tregister($0400000b), -tregister($0400000c), -tregister($0400000d), -tregister($0400000e), -tregister($0400000f) +tregister($040C0000), +tregister($040C0001), +tregister($040C0002), +tregister($040C0003), +tregister($040C0004), +tregister($040C0005), +tregister($040C0006), +tregister($040C0007), +tregister($040C0008), +tregister($040C0009), +tregister($040C000a), +tregister($040C000b), +tregister($040C000c), +tregister($040C000d), +tregister($040C000e), +tregister($040C000f), +tregister($040D0000), +tregister($040D0001), +tregister($040D0002), +tregister($040D0003), +tregister($040D0004), +tregister($040D0005), +tregister($040D0006), +tregister($040D0007), +tregister($040D0008), +tregister($040D0009), +tregister($040D000a), +tregister($040D000b), +tregister($040D000c), +tregister($040D000d), +tregister($040D000e), +tregister($040D000f) diff --git a/compiler/x86_64/r8664op.inc b/compiler/x86_64/r8664op.inc index 1add3b5dfe..6e70e28784 100644 --- a/compiler/x86_64/r8664op.inc +++ b/compiler/x86_64/r8664op.inc @@ -124,4 +124,20 @@ 4, 5, 6, +7, +0, +1, +2, +3, +4, +5, +6, +7, +0, +1, +2, +3, +4, +5, +6, 7 diff --git a/compiler/x86_64/r8664ot.inc b/compiler/x86_64/r8664ot.inc index dae62455c5..77462e1776 100644 --- a/compiler/x86_64/r8664ot.inc +++ b/compiler/x86_64/r8664ot.inc @@ -124,4 +124,20 @@ OT_XMMREG, OT_XMMREG, OT_XMMREG, OT_XMMREG, -OT_XMMREG +OT_XMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG, +OT_YMMREG diff --git a/compiler/x86_64/r8664rni.inc b/compiler/x86_64/r8664rni.inc index 62da4453df..fa5af9efcd 100644 --- a/compiler/x86_64/r8664rni.inc +++ b/compiler/x86_64/r8664rni.inc @@ -101,6 +101,22 @@ 123, 124, 125, +126, +127, +128, +129, +130, +131, +132, +133, +134, +135, +136, +137, +138, +139, +140, +141, 71, 72, 73, diff --git a/compiler/x86_64/r8664sri.inc b/compiler/x86_64/r8664sri.inc index 35409c3e26..2cb03299ab 100644 --- a/compiler/x86_64/r8664sri.inc +++ b/compiler/x86_64/r8664sri.inc @@ -124,4 +124,20 @@ 116, 117, 118, -119 +119, +126, +127, +136, +137, +138, +139, +140, +141, +128, +129, +130, +131, +132, +133, +134, +135 diff --git a/compiler/x86_64/r8664stab.inc b/compiler/x86_64/r8664stab.inc index 4cd671016f..a5abff273c 100644 --- a/compiler/x86_64/r8664stab.inc +++ b/compiler/x86_64/r8664stab.inc @@ -124,4 +124,20 @@ 29, 30, 31, +32, +17, +18, +19, +20, +21, +22, +23, +24, +25, +26, +27, +28, +29, +30, +31, 32 diff --git a/compiler/x86_64/r8664std.inc b/compiler/x86_64/r8664std.inc index e00c911af5..15cd8cbe8c 100644 --- a/compiler/x86_64/r8664std.inc +++ b/compiler/x86_64/r8664std.inc @@ -124,4 +124,20 @@ 'xmm12', 'xmm13', 'xmm14', -'xmm15' +'xmm15', +'ymm0', +'ymm1', +'ymm2', +'ymm3', +'ymm4', +'ymm5', +'ymm6', +'ymm7', +'ymm8', +'ymm9', +'ymm10', +'ymm11', +'ymm12', +'ymm13', +'ymm14', +'ymm15' diff --git a/compiler/x86_64/x8664ats.inc b/compiler/x86_64/x8664ats.inc index 31bc9cd421..2f06270fe3 100644 --- a/compiler/x86_64/x8664ats.inc +++ b/compiler/x86_64/x8664ats.inc @@ -417,7 +417,7 @@ attsufNONE, attsufNONE, attsufNONE, attsufNONE, -attsufINT, +attsufMM, attsufINT, attsufNONE, attsufINT, @@ -534,7 +534,7 @@ attsufNONE, attsufNONE, attsufINT, attsufNONE, -attsufINT, +attsufMM, attsufNONE, attsufNONE, attsufNONE, @@ -684,5 +684,264 @@ attsufNONE, attsufNONE, attsufNONE, attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufMM, +attsufMM, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufMM, +attsufMM, +attsufNONE, +attsufNONE, +attsufMM, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, +attsufNONE, attsufNONE ); diff --git a/compiler/x86_64/x8664att.inc b/compiler/x86_64/x8664att.inc index a591dad220..14ca3fbc0b 100644 --- a/compiler/x86_64/x8664att.inc +++ b/compiler/x86_64/x8664att.inc @@ -684,5 +684,264 @@ 'aeskeygenassist', 'stosq', 'lodsq', -'cmpsq' +'cmpsq', +'vaddpd', +'vaddps', +'vaddsd', +'vaddss', +'vaddsubpd', +'vaddsubps', +'vaesdec', +'vaesdeclast', +'vaesenc', +'vaesenclast', +'vaesimc', +'vaeskeygenassist', +'vandnpd', +'vandnps', +'vandpd', +'vandps', +'vblendpd', +'vblendps', +'vblendvpd', +'vblendvps', +'vbroadcastf128', +'vbroadcastsd', +'vbroadcastss', +'vcmppd', +'vcmpps', +'vcmpsd', +'vcmpss', +'vcomisd', +'vcomiss', +'vcvtdq2pd', +'vcvtdq2ps', +'vcvtpd2dq', +'vcvtpd2ps', +'vcvtps2dq', +'vcvtps2pd', +'vcvtsd2si', +'vcvtsd2ss', +'vcvtsi2sd', +'vcvtsi2ss', +'vcvtss2sd', +'vcvtss2si', +'vcvttpd2dq', +'vcvttps2dq', +'vcvttsd2si', +'vcvttss2si', +'vdivpd', +'vdivps', +'vdivsd', +'vdivss', +'vdppd', +'vdpps', +'vextractf128', +'vextractps', +'vhaddpd', +'vhaddps', +'vhsubpd', +'vhsubps', +'vinsertf128', +'vinsertps', +'vlddqu', +'vldmxcsr', +'vmaskmovdqu', +'vmaskmovpd', +'vmaskmovps', +'vmaxpd', +'vmaxps', +'vmaxsd', +'vmaxss', +'vminpd', +'vminps', +'vminsd', +'vminss', +'vmovapd', +'vmovaps', +'vmovd', +'vmovddup', +'vmovdqa', +'vmovdqu', +'vmovhlps', +'vmovhpd', +'vmovhps', +'vmovlhps', +'vmovlpd', +'vmovlps', +'vmovmskpd', +'vmovmskps', +'vmovntdq', +'vmovntdqa', +'vmovntpd', +'vmovntps', +'vmovq', +'vmovsd', +'vmovshdup', +'vmovsldup', +'vmovss', +'vmovupd', +'vmovups', +'vmpsadbw', +'vmulpd', +'vmulps', +'vmulsd', +'vmulss', +'vorpd', +'vorps', +'vpabsb', +'vpabsd', +'vpabsw', +'vpackssdw', +'vpacksswb', +'vpackusdw', +'vpackuswb', +'vpaddb', +'vpaddd', +'vpaddq', +'vpaddsb', +'vpaddsw', +'vpaddusb', +'vpaddusw', +'vpaddw', +'vpalignr', +'vpand', +'vpandn', +'vpavgb', +'vpavgw', +'vpblendvb', +'vpblendw', +'vpclmulqdq', +'vpcmpeqb', +'vpcmpeqd', +'vpcmpeqq', +'vpcmpeqw', +'vpcmpestri', +'vpcmpestrm', +'vpcmpgtb', +'vpcmpgtd', +'vpcmpgtq', +'vpcmpgtw', +'vpcmpistri', +'vpcmpistrm', +'vperm2f128', +'vpermilpd', +'vpermilps', +'vpextrb', +'vpextrd', +'vpextrq', +'vpextrw', +'vphaddd', +'vphaddsw', +'vphaddw', +'vphminposuw', +'vphsubd', +'vphsubsw', +'vphsubw', +'vpinsrb', +'vpinsrd', +'vpinsrq', +'vpinsrw', +'vpmaddubsw', +'vpmaddwd', +'vpmaxsb', +'vpmaxsd', +'vpmaxsw', +'vpmaxub', +'vpmaxud', +'vpmaxuw', +'vpminsb', +'vpminsd', +'vpminsw', +'vpminub', +'vpminud', +'vpminuw', +'vpmovmskb', +'vpmovsxbd', +'vpmovsxbq', +'vpmovsxbw', +'vpmovsxdq', +'vpmovsxwd', +'vpmovsxwq', +'vpmovzxbd', +'vpmovzxbq', +'vpmovzxbw', +'vpmovzxdq', +'vpmovzxwd', +'vpmovzxwq', +'vpmuldq', +'vpmulhrsw', +'vpmulhuw', +'vpmulhw', +'vpmulld', +'vpmullw', +'vpmuludq', +'vpor', +'vpsadbw', +'vpshufb', +'vpshufd', +'vpshufhw', +'vpshuflw', +'vpsignb', +'vpsignd', +'vpsignw', +'vpslld', +'vpslldq', +'vpsllq', +'vpsllw', +'vpsrad', +'vpsraw', +'vpsrld', +'vpsrldq', +'vpsrlq', +'vpsrlw', +'vpsubb', +'vpsubd', +'vpsubq', +'vpsubsb', +'vpsubsw', +'vpsubusb', +'vpsubusw', +'vpsubw', +'vptest', +'vpunpckhbw', +'vpunpckhdq', +'vpunpckhqdq', +'vpunpckhwd', +'vpunpcklbw', +'vpunpckldq', +'vpunpcklqdq', +'vpunpcklwd', +'vpxor', +'vrcpps', +'vrcpss', +'vroundpd', +'vroundps', +'vroundsd', +'vroundss', +'vrsqrtps', +'vrsqrtss', +'vshufpd', +'vshufps', +'vsqrtpd', +'vsqrtps', +'vsqrtsd', +'vsqrtss', +'vstmxcsr', +'vsubpd', +'vsubps', +'vsubsd', +'vsubss', +'vtestpd', +'vtestps', +'vucomisd', +'vucomiss', +'vunpckhpd', +'vunpckhps', +'vunpcklpd', +'vunpcklps', +'vxorpd', +'vxorps', +'vzeroall', +'vzeroupper' ); diff --git a/compiler/x86_64/x8664int.inc b/compiler/x86_64/x8664int.inc index b6cc4caa78..3a3f4b4631 100644 --- a/compiler/x86_64/x8664int.inc +++ b/compiler/x86_64/x8664int.inc @@ -684,5 +684,264 @@ 'aeskeygenassist', 'stosq', 'lodsq', -'cmpsq' +'cmpsq', +'vaddpd', +'vaddps', +'vaddsd', +'vaddss', +'vaddsubpd', +'vaddsubps', +'vaesdec', +'vaesdeclast', +'vaesenc', +'vaesenclast', +'vaesimc', +'vaeskeygenassist', +'vandnpd', +'vandnps', +'vandpd', +'vandps', +'vblendpd', +'vblendps', +'vblendvpd', +'vblendvps', +'vbroadcastf128', +'vbroadcastsd', +'vbroadcastss', +'vcmppd', +'vcmpps', +'vcmpsd', +'vcmpss', +'vcomisd', +'vcomiss', +'vcvtdq2pd', +'vcvtdq2ps', +'vcvtpd2dq', +'vcvtpd2ps', +'vcvtps2dq', +'vcvtps2pd', +'vcvtsd2si', +'vcvtsd2ss', +'vcvtsi2sd', +'vcvtsi2ss', +'vcvtss2sd', +'vcvtss2si', +'vcvttpd2dq', +'vcvttps2dq', +'vcvttsd2si', +'vcvttss2si', +'vdivpd', +'vdivps', +'vdivsd', +'vdivss', +'vdppd', +'vdpps', +'vextractf128', +'vextractps', +'vhaddpd', +'vhaddps', +'vhsubpd', +'vhsubps', +'vinsertf128', +'vinsertps', +'vlddqu', +'vldmxcsr', +'vmaskmovdqu', +'vmaskmovpd', +'vmaskmovps', +'vmaxpd', +'vmaxps', +'vmaxsd', +'vmaxss', +'vminpd', +'vminps', +'vminsd', +'vminss', +'vmovapd', +'vmovaps', +'vmovd', +'vmovddup', +'vmovdqa', +'vmovdqu', +'vmovhlps', +'vmovhpd', +'vmovhps', +'vmovlhps', +'vmovlpd', +'vmovlps', +'vmovmskpd', +'vmovmskps', +'vmovntdq', +'vmovntdqa', +'vmovntpd', +'vmovntps', +'vmovq', +'vmovsd', +'vmovshdup', +'vmovsldup', +'vmovss', +'vmovupd', +'vmovups', +'vmpsadbw', +'vmulpd', +'vmulps', +'vmulsd', +'vmulss', +'vorpd', +'vorps', +'vpabsb', +'vpabsd', +'vpabsw', +'vpackssdw', +'vpacksswb', +'vpackusdw', +'vpackuswb', +'vpaddb', +'vpaddd', +'vpaddq', +'vpaddsb', +'vpaddsw', +'vpaddusb', +'vpaddusw', +'vpaddw', +'vpalignr', +'vpand', +'vpandn', +'vpavgb', +'vpavgw', +'vpblendvb', +'vpblendw', +'vpclmulqdq', +'vpcmpeqb', +'vpcmpeqd', +'vpcmpeqq', +'vpcmpeqw', +'vpcmpestri', +'vpcmpestrm', +'vpcmpgtb', +'vpcmpgtd', +'vpcmpgtq', +'vpcmpgtw', +'vpcmpistri', +'vpcmpistrm', +'vperm2f128', +'vpermilpd', +'vpermilps', +'vpextrb', +'vpextrd', +'vpextrq', +'vpextrw', +'vphaddd', +'vphaddsw', +'vphaddw', +'vphminposuw', +'vphsubd', +'vphsubsw', +'vphsubw', +'vpinsrb', +'vpinsrd', +'vpinsrq', +'vpinsrw', +'vpmaddubsw', +'vpmaddwd', +'vpmaxsb', +'vpmaxsd', +'vpmaxsw', +'vpmaxub', +'vpmaxud', +'vpmaxuw', +'vpminsb', +'vpminsd', +'vpminsw', +'vpminub', +'vpminud', +'vpminuw', +'vpmovmskb', +'vpmovsxbd', +'vpmovsxbq', +'vpmovsxbw', +'vpmovsxdq', +'vpmovsxwd', +'vpmovsxwq', +'vpmovzxbd', +'vpmovzxbq', +'vpmovzxbw', +'vpmovzxdq', +'vpmovzxwd', +'vpmovzxwq', +'vpmuldq', +'vpmulhrsw', +'vpmulhuw', +'vpmulhw', +'vpmulld', +'vpmullw', +'vpmuludq', +'vpor', +'vpsadbw', +'vpshufb', +'vpshufd', +'vpshufhw', +'vpshuflw', +'vpsignb', +'vpsignd', +'vpsignw', +'vpslld', +'vpslldq', +'vpsllq', +'vpsllw', +'vpsrad', +'vpsraw', +'vpsrld', +'vpsrldq', +'vpsrlq', +'vpsrlw', +'vpsubb', +'vpsubd', +'vpsubq', +'vpsubsb', +'vpsubsw', +'vpsubusb', +'vpsubusw', +'vpsubw', +'vptest', +'vpunpckhbw', +'vpunpckhdq', +'vpunpckhqdq', +'vpunpckhwd', +'vpunpcklbw', +'vpunpckldq', +'vpunpcklqdq', +'vpunpcklwd', +'vpxor', +'vrcpps', +'vrcpss', +'vroundpd', +'vroundps', +'vroundsd', +'vroundss', +'vrsqrtps', +'vrsqrtss', +'vshufpd', +'vshufps', +'vsqrtpd', +'vsqrtps', +'vsqrtsd', +'vsqrtss', +'vstmxcsr', +'vsubpd', +'vsubps', +'vsubsd', +'vsubss', +'vtestpd', +'vtestps', +'vucomisd', +'vucomiss', +'vunpckhpd', +'vunpckhps', +'vunpcklpd', +'vunpcklps', +'vxorpd', +'vxorps', +'vzeroall', +'vzeroupper' ); diff --git a/compiler/x86_64/x8664nop.inc b/compiler/x86_64/x8664nop.inc index c2713bb5c9..d666800c80 100644 --- a/compiler/x86_64/x8664nop.inc +++ b/compiler/x86_64/x8664nop.inc @@ -1,2 +1,2 @@ { don't edit, this file is generated from x86ins.dat } -1219; +1667; diff --git a/compiler/x86_64/x8664op.inc b/compiler/x86_64/x8664op.inc index 4070734e54..fbbb16b8c6 100644 --- a/compiler/x86_64/x8664op.inc +++ b/compiler/x86_64/x8664op.inc @@ -684,5 +684,264 @@ A_AESIMC, A_AESKEYGENASSIST, A_STOSQ, A_LODSQ, -A_CMPSQ +A_CMPSQ, +A_VADDPD, +A_VADDPS, +A_VADDSD, +A_VADDSS, +A_VADDSUBPD, +A_VADDSUBPS, +A_VAESDEC, +A_VAESDECLAST, +A_VAESENC, +A_VAESENCLAST, +A_VAESIMC, +A_VAESKEYGENASSIST, +A_VANDNPD, +A_VANDNPS, +A_VANDPD, +A_VANDPS, +A_VBLENDPD, +A_VBLENDPS, +A_VBLENDVPD, +A_VBLENDVPS, +A_VBROADCASTF128, +A_VBROADCASTSD, +A_VBROADCASTSS, +A_VCMPPD, +A_VCMPPS, +A_VCMPSD, +A_VCMPSS, +A_VCOMISD, +A_VCOMISS, +A_VCVTDQ2PD, +A_VCVTDQ2PS, +A_VCVTPD2DQ, +A_VCVTPD2PS, +A_VCVTPS2DQ, +A_VCVTPS2PD, +A_VCVTSD2SI, +A_VCVTSD2SS, +A_VCVTSI2SD, +A_VCVTSI2SS, +A_VCVTSS2SD, +A_VCVTSS2SI, +A_VCVTTPD2DQ, +A_VCVTTPS2DQ, +A_VCVTTSD2SI, +A_VCVTTSS2SI, +A_VDIVPD, +A_VDIVPS, +A_VDIVSD, +A_VDIVSS, +A_VDPPD, +A_VDPPS, +A_VEXTRACTF128, +A_VEXTRACTPS, +A_VHADDPD, +A_VHADDPS, +A_VHSUBPD, +A_VHSUBPS, +A_VINSERTF128, +A_VINSERTPS, +A_VLDDQU, +A_VLDMXCSR, +A_VMASKMOVDQU, +A_VMASKMOVPD, +A_VMASKMOVPS, +A_VMAXPD, +A_VMAXPS, +A_VMAXSD, +A_VMAXSS, +A_VMINPD, +A_VMINPS, +A_VMINSD, +A_VMINSS, +A_VMOVAPD, +A_VMOVAPS, +A_VMOVD, +A_VMOVDDUP, +A_VMOVDQA, +A_VMOVDQU, +A_VMOVHLPS, +A_VMOVHPD, +A_VMOVHPS, +A_VMOVLHPS, +A_VMOVLPD, +A_VMOVLPS, +A_VMOVMSKPD, +A_VMOVMSKPS, +A_VMOVNTDQ, +A_VMOVNTDQA, +A_VMOVNTPD, +A_VMOVNTPS, +A_VMOVQ, +A_VMOVSD, +A_VMOVSHDUP, +A_VMOVSLDUP, +A_VMOVSS, +A_VMOVUPD, +A_VMOVUPS, +A_VMPSADBW, +A_VMULPD, +A_VMULPS, +A_VMULSD, +A_VMULSS, +A_VORPD, +A_VORPS, +A_VPABSB, +A_VPABSD, +A_VPABSW, +A_VPACKSSDW, +A_VPACKSSWB, +A_VPACKUSDW, +A_VPACKUSWB, +A_VPADDB, +A_VPADDD, +A_VPADDQ, +A_VPADDSB, +A_VPADDSW, +A_VPADDUSB, +A_VPADDUSW, +A_VPADDW, +A_VPALIGNR, +A_VPAND, +A_VPANDN, +A_VPAVGB, +A_VPAVGW, +A_VPBLENDVB, +A_VPBLENDW, +A_VPCLMULQDQ, +A_VPCMPEQB, +A_VPCMPEQD, +A_VPCMPEQQ, +A_VPCMPEQW, +A_VPCMPESTRI, +A_VPCMPESTRM, +A_VPCMPGTB, +A_VPCMPGTD, +A_VPCMPGTQ, +A_VPCMPGTW, +A_VPCMPISTRI, +A_VPCMPISTRM, +A_VPERM2F128, +A_VPERMILPD, +A_VPERMILPS, +A_VPEXTRB, +A_VPEXTRD, +A_VPEXTRQ, +A_VPEXTRW, +A_VPHADDD, +A_VPHADDSW, +A_VPHADDW, +A_VPHMINPOSUW, +A_VPHSUBD, +A_VPHSUBSW, +A_VPHSUBW, +A_VPINSRB, +A_VPINSRD, +A_VPINSRQ, +A_VPINSRW, +A_VPMADDUBSW, +A_VPMADDWD, +A_VPMAXSB, +A_VPMAXSD, +A_VPMAXSW, +A_VPMAXUB, +A_VPMAXUD, +A_VPMAXUW, +A_VPMINSB, +A_VPMINSD, +A_VPMINSW, +A_VPMINUB, +A_VPMINUD, +A_VPMINUW, +A_VPMOVMSKB, +A_VPMOVSXBD, +A_VPMOVSXBQ, +A_VPMOVSXBW, +A_VPMOVSXDQ, +A_VPMOVSXWD, +A_VPMOVSXWQ, +A_VPMOVZXBD, +A_VPMOVZXBQ, +A_VPMOVZXBW, +A_VPMOVZXDQ, +A_VPMOVZXWD, +A_VPMOVZXWQ, +A_VPMULDQ, +A_VPMULHRSW, +A_VPMULHUW, +A_VPMULHW, +A_VPMULLD, +A_VPMULLW, +A_VPMULUDQ, +A_VPOR, +A_VPSADBW, +A_VPSHUFB, +A_VPSHUFD, +A_VPSHUFHW, +A_VPSHUFLW, +A_VPSIGNB, +A_VPSIGND, +A_VPSIGNW, +A_VPSLLD, +A_VPSLLDQ, +A_VPSLLQ, +A_VPSLLW, +A_VPSRAD, +A_VPSRAW, +A_VPSRLD, +A_VPSRLDQ, +A_VPSRLQ, +A_VPSRLW, +A_VPSUBB, +A_VPSUBD, +A_VPSUBQ, +A_VPSUBSB, +A_VPSUBSW, +A_VPSUBUSB, +A_VPSUBUSW, +A_VPSUBW, +A_VPTEST, +A_VPUNPCKHBW, +A_VPUNPCKHDQ, +A_VPUNPCKHQDQ, +A_VPUNPCKHWD, +A_VPUNPCKLBW, +A_VPUNPCKLDQ, +A_VPUNPCKLQDQ, +A_VPUNPCKLWD, +A_VPXOR, +A_VRCPPS, +A_VRCPSS, +A_VROUNDPD, +A_VROUNDPS, +A_VROUNDSD, +A_VROUNDSS, +A_VRSQRTPS, +A_VRSQRTSS, +A_VSHUFPD, +A_VSHUFPS, +A_VSQRTPD, +A_VSQRTPS, +A_VSQRTSD, +A_VSQRTSS, +A_VSTMXCSR, +A_VSUBPD, +A_VSUBPS, +A_VSUBSD, +A_VSUBSS, +A_VTESTPD, +A_VTESTPS, +A_VUCOMISD, +A_VUCOMISS, +A_VUNPCKHPD, +A_VUNPCKHPS, +A_VUNPCKLPD, +A_VUNPCKLPS, +A_VXORPD, +A_VXORPS, +A_VZEROALL, +A_VZEROUPPER ); diff --git a/compiler/x86_64/x8664pro.inc b/compiler/x86_64/x8664pro.inc index 4a8f2f7fa4..e57a923f65 100644 --- a/compiler/x86_64/x8664pro.inc +++ b/compiler/x86_64/x8664pro.inc @@ -684,5 +684,264 @@ (Ch: (Ch_All, Ch_None, Ch_None)), (Ch: (Ch_RRAX, Ch_WMemEDI, Ch_RWRDI)), (Ch: (Ch_WRAX, Ch_RWRSI, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), +(Ch: (Ch_All, Ch_None, Ch_None)), (Ch: (Ch_All, Ch_None, Ch_None)) ); diff --git a/compiler/x86_64/x8664tab.inc b/compiler/x86_64/x8664tab.inc index 5a89969928..c9d642ea12 100644 --- a/compiler/x86_64/x8664tab.inc +++ b/compiler/x86_64/x8664tab.inc @@ -3944,7 +3944,7 @@ ( opcode : A_POR; ops : 2; - optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); code : #241#2#15#235#72; flags : if_willamette or if_sse2 or if_sm ), @@ -6086,21 +6086,14 @@ ( opcode : A_CVTPI2PS; ops : 2; - optypes : (ot_xmmreg,ot_memory,ot_none,ot_none); - code : #217#2#15#42#72; - flags : if_katmai or if_sse or if_mmx - ), - ( - opcode : A_CVTPI2PS; - ops : 2; - optypes : (ot_xmmreg,ot_mmxreg,ot_none,ot_none); + optypes : (ot_xmmreg,ot_mmxrm,ot_none,ot_none); code : #217#2#15#42#72; flags : if_katmai or if_sse or if_mmx ), ( opcode : A_CVTPS2PI; ops : 2; - optypes : (ot_mmxreg,ot_memory,ot_none,ot_none); + optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none); code : #217#2#15#45#72; flags : if_katmai or if_sse or if_mmx ), @@ -6114,21 +6107,21 @@ ( opcode : A_CVTSI2SS; ops : 2; - optypes : (ot_xmmreg,ot_memory,ot_none,ot_none); + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none); code : #219#209#2#15#42#72; flags : if_katmai or if_sse ), ( opcode : A_CVTSI2SS; ops : 2; - optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none); + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none); code : #219#209#2#15#42#72; - flags : if_katmai or if_sse + flags : if_katmai or if_sse or if_x86_64 ), ( opcode : A_CVTSS2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none); code : #219#208#2#15#45#72; flags : if_katmai or if_sse ), @@ -6142,7 +6135,7 @@ ( opcode : A_CVTTPS2PI; ops : 2; - optypes : (ot_mmxreg,ot_memory,ot_none,ot_none); + optypes : (ot_mmxreg,ot_memory or ot_bits64,ot_none,ot_none); code : #217#2#15#44#72; flags : if_katmai or if_sse or if_mmx ), @@ -6156,7 +6149,7 @@ ( opcode : A_CVTTSS2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits32,ot_none,ot_none); code : #219#208#2#15#44#72; flags : if_katmai or if_sse ), @@ -7087,7 +7080,14 @@ ( opcode : A_CVTDQ2PD; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #219#2#15#230#72; + flags : if_willamette or if_sse2 + ), + ( + opcode : A_CVTDQ2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); code : #219#2#15#230#72; flags : if_willamette or if_sse2 ), @@ -7136,63 +7136,91 @@ ( opcode : A_CVTPS2PD; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #2#15#90#72; + flags : if_willamette or if_sse2 + ), + ( + opcode : A_CVTPS2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); code : #2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSD2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_xmmreg,ot_none,ot_none); - code : #220#208#2#15#45#72; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #220#2#15#45#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSD2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#2#15#45#72; + flags : if_willamette or if_sse2 + ), + ( + opcode : A_CVTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); code : #220#208#2#15#45#72; + flags : if_willamette or if_sse2 or if_x86_64 + ), + ( + opcode : A_CVTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#208#2#15#45#72; + flags : if_willamette or if_sse2 or if_x86_64 + ), + ( + opcode : A_CVTSD2SS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #220#2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSD2SS; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); code : #220#2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSI2SD; ops : 2; - optypes : (ot_xmmreg,ot_reg32 or ot_bits64,ot_none,ot_none); - code : #220#209#2#15#42#72; + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none); + code : #220#2#15#42#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTSI2SD; ops : 2; - optypes : (ot_xmmreg,ot_memory,ot_none,ot_none); - code : #220#209#2#15#42#72; - flags : if_willamette or if_sse2 + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none); + code : #214#220#209#2#15#42#72; + flags : if_willamette or if_sse2 or if_x86_64 ), ( opcode : A_CVTSS2SD; ops : 2; - optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); code : #219#2#15#90#72; flags : if_willamette or if_sse2 ), ( - opcode : A_CVTTPD2PI; + opcode : A_CVTSS2SD; ops : 2; - optypes : (ot_mmxreg,ot_xmmreg,ot_none,ot_none); - code : #241#2#15#44#72; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#2#15#90#72; flags : if_willamette or if_sse2 ), ( opcode : A_CVTTPD2PI; ops : 2; - optypes : (ot_mmxreg,ot_memory,ot_none,ot_none); + optypes : (ot_mmxreg,ot_xmmrm,ot_none,ot_none); code : #241#2#15#44#72; flags : if_willamette or if_sse2 ), @@ -7220,7 +7248,7 @@ ( opcode : A_CVTTSD2SI; ops : 2; - optypes : (ot_reg32 or ot_bits64,ot_memory,ot_none,ot_none); + optypes : (ot_reg32 or ot_bits64,ot_memory or ot_bits64,ot_none,ot_none); code : #220#208#2#15#44#72; flags : if_willamette or if_sse2 ), @@ -8532,5 +8560,3113 @@ optypes : (ot_none,ot_none,ot_none,ot_none); code : #214#1#167; flags : if_x86_64 + ), + ( + opcode : A_VADDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#88#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #220#242#244#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VADDSUBPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #220#242#248#1#208#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESDEC; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#222#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESDECLAST; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#223#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESENC; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#220#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESENCLAST; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#221#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESIMC; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#219#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VAESKEYGENASSIST; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#223#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDNPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#85#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VANDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#84#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#13#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#13#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#12#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#12#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg); + code : #241#242#250#1#75#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg); + code : #241#242#244#250#1#75#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg); + code : #241#242#250#1#74#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBLENDVPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_ymmreg); + code : #241#242#244#250#1#74#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTF128; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #241#242#244#249#1#26#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTSD; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#244#249#1#25#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTSS; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#244#249#1#24#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VBROADCASTSS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#24#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #242#244#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8); + code : #220#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #220#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8); + code : #219#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCMPSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #219#242#248#1#194#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#47#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #219#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmreg,ot_none,ot_none); + code : #219#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PD; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #219#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTDQ2PS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #220#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none); + code : #220#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2PS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPD2PS; + ops : 2; + optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2DQ; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2PD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #242#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2PD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTPS2PD; + ops : 2; + optypes : (ot_ymmreg,ot_xmmrm,ot_none,ot_none); + code : #242#244#248#1#90#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #220#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSD2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSI2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none); + code : #220#242#248#1#42#61#80; + flags : if_avx or if_sandybridge or if_sd + ), + ( + opcode : A_VCVTSI2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none); + code : #220#242#243#248#1#42#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSI2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none); + code : #219#242#248#1#42#61#80; + flags : if_avx or if_sandybridge or if_sd + ), + ( + opcode : A_VCVTSI2SS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none); + code : #219#242#243#248#1#42#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#90#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #219#242#243#248#1#45#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPD2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#230#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPS2DQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTPS2DQ; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#91#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSD2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #220#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_memory or ot_bits32,ot_none,ot_none); + code : #219#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VCVTTSS2SI; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #219#242#243#248#1#44#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDIVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#94#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDPPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#65#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDPPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#64#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VDPPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#64#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VEXTRACTF128; + ops : 3; + optypes : (ot_xmmrm,ot_ymmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#25#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VEXTRACTPS; + ops : 3; + optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#23#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #220#242#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHADDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #220#242#244#248#1#124#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #220#242#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VHSUBPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #220#242#244#248#1#125#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VINSERTF128; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#24#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VINSERTPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8); + code : #241#242#250#1#33#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VINSERTPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #241#242#250#1#33#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VLDDQU; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #220#242#248#1#240#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VLDDQU; + ops : 2; + optypes : (ot_ymmreg,ot_memory or ot_bits256,ot_none,ot_none); + code : #220#242#244#248#1#240#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VLDMXCSR; + ops : 1; + optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none); + code : #242#248#1#174#130; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVDQU; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#247#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none); + code : #241#242#244#249#1#47#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none); + code : #241#242#249#1#47#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none); + code : #241#242#244#249#1#45#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none); + code : #241#242#249#1#45#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_ymmreg,ot_none); + code : #241#242#244#249#1#46#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_xmmreg,ot_none); + code : #241#242#249#1#46#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_memory or ot_bits256,ot_none); + code : #241#242#244#249#1#44#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMASKMOVPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits128,ot_none); + code : #241#242#249#1#44#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMAXSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#95#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMINSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#93#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPD; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#40#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVAPS; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#41#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVD; + ops : 2; + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits32,ot_none,ot_none); + code : #241#242#248#1#110#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVD; + ops : 2; + optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#126#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDDUP; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #220#242#244#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDDUP; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDDUP; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQA; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#111#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVDQU; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #219#242#244#248#1#127#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHLPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #242#248#1#18#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPD; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#23#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #241#242#248#1#22#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #242#248#1#22#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVHPS; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#23#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLHPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #242#248#1#22#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPD; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#19#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #241#242#248#1#18#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPS; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#19#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVLPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #242#248#1#18#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPD; + ops : 2; + optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg32,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVMSKPS; + ops : 2; + optypes : (ot_reg64,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#80#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTDQ; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#231#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTDQ; + ops : 2; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#231#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTDQA; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits128,ot_none,ot_none); + code : #241#242#249#1#42#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPD; + ops : 2; + optypes : (ot_memory or ot_bits256,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPD; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPS; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVNTPS; + ops : 2; + optypes : (ot_memory or ot_bits128,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#43#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVQ; + ops : 2; + optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #241#242#243#248#1#126#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVQ; + ops : 2; + optypes : (ot_xmmreg,ot_rm_gpr or ot_bits64,ot_none,ot_none); + code : #241#242#243#248#1#110#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#16#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #220#242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#17#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSD; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #220#242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSHDUP; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#22#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSHDUP; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#22#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSLDUP; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #219#242#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSLDUP; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #219#242#244#248#1#18#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#16#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #219#242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#17#61#66; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVSS; + ops : 2; + optypes : (ot_memory or ot_bits64,ot_xmmreg,ot_none,ot_none); + code : #219#242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPD; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #241#242#244#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_xmmrm,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#16#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMOVUPS; + ops : 2; + optypes : (ot_ymmrm,ot_ymmreg,ot_none,ot_none); + code : #242#244#248#1#17#65; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMPSADBW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#66#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VMULSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#89#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VORPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#86#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VORPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#86#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VORPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#86#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPABSB; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#28#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPABSD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#30#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPABSW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#29#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKSSDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#107#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKSSWB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#99#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKUSDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#43#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPACKUSWB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#103#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#252#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#254#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#212#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#236#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#237#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDUSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#220#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDUSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#221#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPADDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#253#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPALIGNR; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#15#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPAND; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#219#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPANDN; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#223#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPAVGB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#224#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPAVGW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#227#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPBLENDVB; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_xmmreg); + code : #241#242#250#1#76#61#80#247; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPBLENDW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#14#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCLMULQDQ; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#250#1#68#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#116#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#118#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#41#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPEQW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#117#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPESTRI; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#97#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPESTRM; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#96#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#100#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#102#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#55#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPGTW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#101#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPISTRI; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#99#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPCMPISTRM; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#98#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERM2F128; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#250#1#6#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#249#1#13#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#5#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#5#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#13#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#249#1#12#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#4#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#4#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPERMILPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#12#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRB; + ops : 3; + optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#20#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRB; + ops : 3; + optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#20#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRB; + ops : 3; + optypes : (ot_memory or ot_bits8,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#20#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRD; + ops : 3; + optypes : (ot_rm_gpr or ot_bits32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#22#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRQ; + ops : 3; + optypes : (ot_rm_gpr or ot_bits64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#243#250#1#22#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#197#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#197#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg32,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#21#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_reg64,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#21#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPEXTRW; + ops : 3; + optypes : (ot_memory or ot_bits16,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#21#65#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHADDD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#2#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHADDSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#3#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHADDW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#1#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHMINPOSUW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#65#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHSUBD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#6#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHSUBSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#7#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPHSUBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#5#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRB; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8); + code : #241#242#250#1#32#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRB; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits8,ot_immediate or ot_bits8); + code : #241#242#250#1#32#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits32,ot_immediate or ot_bits8); + code : #241#242#250#1#34#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRQ; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_rm_gpr or ot_bits64,ot_immediate or ot_bits8); + code : #241#242#243#250#1#34#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_reg32,ot_immediate or ot_bits8); + code : #241#242#248#1#196#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPINSRW; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits16,ot_immediate or ot_bits8); + code : #241#242#248#1#196#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMADDUBSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#4#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMADDWD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#245#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#60#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#61#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#238#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXUB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#222#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXUD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#63#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMAXUW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#62#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#56#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#57#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#234#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINUB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#218#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINUD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#59#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMINUW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#58#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVMSKB; + ops : 2; + optypes : (ot_reg64,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#215#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVMSKB; + ops : 2; + optypes : (ot_reg32,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#215#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#33#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#33#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none); + code : #241#242#249#1#34#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#34#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBW; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#32#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXBW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#32#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#37#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#37#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#35#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#35#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#36#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVSXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#36#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#49#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#49#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits16,ot_none,ot_none); + code : #241#242#249#1#50#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#50#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBW; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#48#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXBW; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#48#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#53#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXDQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#53#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#249#1#51#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#51#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #241#242#249#1#52#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMOVZXWQ; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#249#1#52#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#40#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULHRSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#11#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULHUW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#228#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULHW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#229#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#64#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#213#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPMULUDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#244#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPOR; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#235#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSADBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#246#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#0#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#112#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFHW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #219#242#248#1#112#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSHUFLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #220#242#248#1#112#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSIGNB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#8#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSIGND; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#10#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSIGNW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#249#1#9#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#114#60#142#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#242#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#143#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#243#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#142#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#113#60#142#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSLLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#241#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#114#60#140#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#226#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#113#60#140#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRAW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#225#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#114#60#138#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#210#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#139#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#115#60#138#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#211#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8,ot_none); + code : #241#242#248#1#113#60#138#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSRLW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#209#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#248#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#250#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#251#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#232#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#233#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBUSB; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#216#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBUSW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#217#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPSUBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#249#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPTEST; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#249#1#23#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPTEST; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#23#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#104#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#106#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHQDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#109#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKHWD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#105#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLBW; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#96#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#98#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLQDQ; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#108#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPUNPCKLWD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#97#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VPXOR; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#239#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#83#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#83#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#83#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRCPSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#83#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#9#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#9#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#244#250#1#8#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8,ot_none); + code : #241#242#250#1#8#72#22; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_immediate or ot_bits8); + code : #241#242#250#1#11#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #241#242#250#1#11#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_immediate or ot_bits8); + code : #241#242#250#1#10#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VROUNDSS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_immediate or ot_bits8); + code : #241#242#250#1#10#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#82#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#82#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#82#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VRSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#82#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPD; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #241#242#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPD; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #241#242#244#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPS; + ops : 4; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_immediate or ot_bits8); + code : #242#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSHUFPS; + ops : 4; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_immediate or ot_bits8); + code : #242#244#248#1#198#61#80#23; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #242#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #242#244#248#1#81#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSQRTSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#81#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSTMXCSR; + ops : 1; + optypes : (ot_memory or ot_bits32,ot_none,ot_none,ot_none); + code : #242#248#1#174#131; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits64,ot_none); + code : #220#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #220#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_memory or ot_bits32,ot_none); + code : #219#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VSUBSS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmreg,ot_none); + code : #219#242#248#1#92#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#15#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPD; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#249#1#15#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPS; + ops : 2; + optypes : (ot_ymmreg,ot_ymmrm,ot_none,ot_none); + code : #241#242#244#249#1#14#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VTESTPS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmrm,ot_none,ot_none); + code : #241#242#249#1#14#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits64,ot_none,ot_none); + code : #241#242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISD; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #241#242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_memory or ot_bits32,ot_none,ot_none); + code : #242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUCOMISS; + ops : 2; + optypes : (ot_xmmreg,ot_xmmreg,ot_none,ot_none); + code : #242#248#1#46#72; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKHPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#21#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VUNPCKLPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#20#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPD; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #241#242#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPD; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #241#242#244#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPS; + ops : 3; + optypes : (ot_xmmreg,ot_xmmreg,ot_xmmrm,ot_none); + code : #242#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VXORPS; + ops : 3; + optypes : (ot_ymmreg,ot_ymmreg,ot_ymmrm,ot_none); + code : #242#244#248#1#87#61#80; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VZEROALL; + ops : 0; + optypes : (ot_none,ot_none,ot_none,ot_none); + code : #242#244#248#1#119; + flags : if_avx or if_sandybridge + ), + ( + opcode : A_VZEROUPPER; + ops : 0; + optypes : (ot_none,ot_none,ot_none,ot_none); + code : #242#248#1#119; + flags : if_avx or if_sandybridge ) ); diff --git a/tests/test/tasm10.pp b/tests/test/tasm10.pp new file mode 100644 index 0000000000..7e0f5ffc9d --- /dev/null +++ b/tests/test/tasm10.pp @@ -0,0 +1,12 @@ +{ %CPU=x86_64 } +{ %fail } + +// in 64-bit mode is needed exact size of memory operand (32- or 64 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + vcvtsi2sd xmm0, xmm0, [RAX] +end; + +begin +end. diff --git a/tests/test/tasm11.pp b/tests/test/tasm11.pp new file mode 100644 index 0000000000..08a826da9f --- /dev/null +++ b/tests/test/tasm11.pp @@ -0,0 +1,12 @@ +{ %CPU=i386,x86_64 } +{ %fail } + +// need exact size of memory operand (128- or 256 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + vcvtpd2dq xmm0, [RAX] +end; + +begin +end. diff --git a/tests/test/tasm12.pp b/tests/test/tasm12.pp new file mode 100644 index 0000000000..c4ae165e26 --- /dev/null +++ b/tests/test/tasm12.pp @@ -0,0 +1,12 @@ +{ %CPU=i386,x86_64 } +{ %fail } + +// need exact size of memory operand (128- or 256 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + vcvtpd2ps xmm0, [RAX] +end; + +begin +end. diff --git a/tests/test/tasm13.pp b/tests/test/tasm13.pp new file mode 100644 index 0000000000..13c69f290c --- /dev/null +++ b/tests/test/tasm13.pp @@ -0,0 +1,12 @@ +{ %CPU=i386,x86_64 } +{ %fail } + +// need exact size of memory operand (128- or 256 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + vcvttpd2dq xmm0, [RAX] +end; + +begin +end. diff --git a/tests/test/tasm14.pp b/tests/test/tasm14.pp new file mode 100644 index 0000000000..86cbd82646 --- /dev/null +++ b/tests/test/tasm14.pp @@ -0,0 +1,57 @@ +{ %CPU=x86_64 } + +// (Almost) every of these instructions use a high register and thus generate REX. +{$asmmode intel} +procedure avxtest; assembler; nostackframe; +asm + VADDPD XMM0, XMM1, [RAX] + $100 + VADDPD YMM2, YMM3, [RAX] + $100 + + VBLENDPD XMM2, XMM5, XMM7, $02 + VBLENDPD YMM2, YMM5, YMM7, $0F + + VBLENDVPS XMM2, XMM5, XMM7, XMM4 + VBLENDVPS YMM0, YMM1, YMM2, YMM5 + + VBROADCASTSD YMM0, [RAX] + + VPEXTRB EAX, XMM0, $00 + + VPINSRD XMM7, XMM1, EAX, $03 + + VZEROALL + +end; + + +const + avxtest_expected : array[0..59] of byte = ( + $C5,$F1,$58,$80,$00,$01,$00,$00, + $C5,$E5,$58,$90,$00,$01,$00,$00, + $C4,$E3,$51,$0D,$D7,$02, + $C4,$E3,$55,$0D,$D7,$0F, + $C4,$E3,$51,$4A,$D7,$40, + $C4,$E3,$75,$4A,$C2,$50, + $C4,$E2,$7D,$19,$00, + $C4,$E3,$79,$14,$C0,$00, + $C4,$E3,$71,$22,$F8,$03, + $C5,$FC,$77); + + + +procedure check(const id: string; const expected: array of byte; p: pointer); +var + i : longint; +begin + for i:=0 to high(expected) do + if expected[i]<>pbyte(p)[i] then + begin + writeln(id, ' mismatch at offset $',hexstr(i,4), ', expected=$',hexstr(expected[i],2),' actual=$',hexstr(pbyte(p)[i],2)); + halt(1); + end; +end; + +begin + check('generic', avxtest_expected, @avxtest); + writeln('ok'); +end. diff --git a/tests/test/tasm15.pp b/tests/test/tasm15.pp new file mode 100644 index 0000000000..d1499c010a --- /dev/null +++ b/tests/test/tasm15.pp @@ -0,0 +1,12 @@ +{ %CPU=x86_64 } +{ %fail } + +// in 64-bit mode is needed exact size of memory operand (32- or 64 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + cvtsi2ss xmm0, [RAX] +end; + +begin +end. diff --git a/tests/test/tasm8.pp b/tests/test/tasm8.pp new file mode 100644 index 0000000000..29a3ed338a --- /dev/null +++ b/tests/test/tasm8.pp @@ -0,0 +1,12 @@ +{ %CPU=x86_64 } +{ %fail } + +// in 64-bit mode is needed exact size of memory operand (32- or 64 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + cvtsi2sd xmm0, [RAX] +end; + +begin +end. diff --git a/tests/test/tasm9.pp b/tests/test/tasm9.pp new file mode 100644 index 0000000000..8a897a0c7b --- /dev/null +++ b/tests/test/tasm9.pp @@ -0,0 +1,12 @@ +{ %CPU=x86_64 } +{ %fail } + +// in 64-bit mode is needed exact size of memory operand (32- or 64 bit) +{$asmmode intel} +procedure test; assembler; nostackframe; +asm + vcvtsi2ss xmm0, xmm0, [RAX] +end; + +begin +end. diff --git a/tests/utils/avx/asmtestgenerator.pas b/tests/utils/avx/asmtestgenerator.pas new file mode 100644 index 0000000000..47c586d1dc --- /dev/null +++ b/tests/utils/avx/asmtestgenerator.pas @@ -0,0 +1,903 @@ +{ + + Copyright (C) <avx-testfile-generator> <Torsten Grundke> + + This source is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at your option) + any later version. + + This code 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. + + A copy of the GNU General Public License is available on the World Wide Web + at <http://www.gnu.org/copyleft/gpl.html>. You can also obtain it by writing + to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. +} + +{$mode objfpc} + +unit asmtestgenerator; + +interface + +uses BaseList, Classes; + +type + TOpType = (otUnknown, otXMMReg, otXMMRM, otXMMRM16, otXMMRM8, otYMMReg, otYMMRM, otEAX, otRAX, otMem32, + otMem8, otMem16, otMem64, otMem128, otMem256, otREG64, otREG32, otRM32, otRM64, otIMM8); + + TOperandListItem = class(TObject) + private + FOpActive: boolean; + FOpNumber: integer; + FOpTyp: TOpType; + FValues: TStringList; + public + constructor Create; + destructor Destroy; override; + + property OpNumber: integer read FOpNumber write FOpNumber; + property OpTyp: TOpType read FOpTyp write FOpTyp; + property OpActive: boolean read FOpActive write FOpActive; + + property Values: TStringList read FValues; + end; + + TOperandList = class(TBaseList) + private + function GetItems(aIndex: integer): TOperandListItem; + + public + function Add(aItem: TOperandListItem): integer; + + property Items[aIndex: integer]: TOperandListItem read GetItems; + end; + + + TAsmTestGenerator = class(TObject) + private + FReg32Base : TStringList; + FReg32Index : TStringList; + FReg64Base : TStringList; + FReg64Index : TStringList; + FReg6432Base : TStringList; + FReg6432Index : TStringList; + + Fx64: boolean; + + procedure MemRegBaseIndexCombi(const aPrefix: String; aSLBaseReg, aSLIndexReg, aRList: TStringList); + + function InternalCalcTestData(const aInst, aOp1, aOp2, aOp3, aOp4: String): TStringList; + public + constructor Create; + destructor Destroy; override; + + class procedure CalcTestData(aX64: boolean; const aInst, aOp1, aOp2, aOp3, aOp4: String; aSL: TStringList); + + property x64: boolean read Fx64; + end; + +implementation + +uses SysUtils, Dialogs; + +{ TOperandListItem } + +constructor TOperandListItem.Create; +begin + inherited; + + FOpActive := false; + FOpNumber := -1; + FOpTyp := otUnknown; + FValues := TStringList.Create; +end; + +destructor TOperandListItem.Destroy; +begin + FreeAndNil(FValues); + inherited; +end; + +{ TOperandList } + +function TOperandList.Add(aItem: TOperandListItem): integer; +begin + result := FList.Add(aItem); +end; + +function TOperandList.GetItems(aIndex: integer): TOperandListItem; +begin + result := TOperandListItem(FList[aIndex]); +end; + +{ TAsmTestGenerator } + +function TAsmTestGenerator.InternalCalcTestData(const aInst, aOp1, aOp2, aOp3, + aOp4: String): TStringList; +var + Item: TOperandListItem; + OItem1: TOperandListItem; + OItem2: TOperandListItem; + OItem3: TOperandListItem; + OItem4: TOperandListItem; + + il_Op: integer; + il_Op1: integer; + il_Op2: integer; + il_Op3: integer; + il_Op4: integer; + + sl_Operand: String; + sl_Inst : String; + sl_RegCombi: String; + sl_Prefix: String; + UsePrefix: boolean; + il_Operands: integer; + UsedParams: cardinal; + UseDefault: boolean; + sl_RegCombi1: string; + sl_RegCombi2: string; + sl_RegCombi3: string; + + function PrepareOperandTyp(const aTyp: String): String; + begin + result := aTyp; + if copy(result, length(result), 1) = '*' then result := copy(result, 1, length(result) - 1); + if result = 'XMMRM128' then result := 'XMMRM'; + if result = 'YMMRM256' then result := 'YMMRM'; + end; + + +begin + result := TStringList.Create; + + OItem1 := TOperandListItem.Create; + try + OItem2 := TOperandListItem.Create; + try + OItem3 := TOperandListItem.Create; + try + OItem4 := TOperandListItem.Create; + try + + UsePrefix := (aInst = 'VCVTPD2DQ') OR + (aInst = 'VCVTPD2PS') OR + (aInst = 'VCVTSI2SD') OR + (aInst = 'VCVTSI2SS') OR + (aInst = 'VCVTTPD2DQ'); + + for il_Op := 1 to 4 do + begin + sl_Prefix := ''; + + case il_Op of + 1: begin + Item := OItem1; + sl_Operand := aOp1; + end; + 2: begin + Item := OItem2; + sl_Operand := aOp2; + end; + 3: begin + Item := OItem3; + sl_Operand := aOp3; + end; + 4: begin + Item := OItem4; + sl_Operand := aOp4; + end; + end; + + sl_Operand := PrepareOperandTyp(sl_Operand); + + if AnsiSameText(sl_Operand, 'XMMREG') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otXMMReg; + Item.OpActive := true; + + Item.Values.Add('XMM0'); + Item.Values.Add('XMM1'); + Item.Values.Add('XMM2'); + Item.Values.Add('XMM3'); + Item.Values.Add('XMM4'); + Item.Values.Add('XMM5'); + Item.Values.Add('XMM6'); + Item.Values.Add('XMM7'); + + if x64 then + begin + if aOp4 <> 'XMMREG' then + begin + Item.Values.Add('XMM8'); + Item.Values.Add('XMM9'); + Item.Values.Add('XMM10'); + Item.Values.Add('XMM11'); + Item.Values.Add('XMM12'); + Item.Values.Add('XMM13'); + Item.Values.Add('XMM14'); + Item.Values.Add('XMM15'); + end + else + begin + Item.Values.Clear; + + Item.Values.Add('XMM0'); + Item.Values.Add('XMM7'); + Item.Values.Add('XMM8'); + Item.Values.Add('XMM15'); + end; + end; + end + else if AnsiSameText(sl_Operand, 'XMMRM') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otXMMRM; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'oword '; + + Item.Values.Add('XMM0'); + Item.Values.Add('XMM1'); + Item.Values.Add('XMM2'); + Item.Values.Add('XMM3'); + Item.Values.Add('XMM4'); + Item.Values.Add('XMM5'); + Item.Values.Add('XMM6'); + Item.Values.Add('XMM7'); + + if x64 then + begin + Item.Values.Add('XMM8'); + Item.Values.Add('XMM9'); + Item.Values.Add('XMM10'); + Item.Values.Add('XMM11'); + Item.Values.Add('XMM12'); + Item.Values.Add('XMM13'); + Item.Values.Add('XMM14'); + Item.Values.Add('XMM15'); + + //Item.Values.Add('[RIP]'); + //Item.Values.Add('[RIP + 16]'); + + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else + begin + MemRegBaseIndexCombi(sl_Prefix, FReg32Base, FReg32Index, Item.Values); + end; + end + else if AnsiSameText(sl_Operand, 'XMMRM8') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otXMMRM8; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'byte '; + + Item.Values.Add('XMM0'); + Item.Values.Add('XMM1'); + Item.Values.Add('XMM2'); + Item.Values.Add('XMM3'); + Item.Values.Add('XMM4'); + Item.Values.Add('XMM5'); + Item.Values.Add('XMM6'); + Item.Values.Add('XMM7'); + + if x64 then + begin + Item.Values.Add('XMM8'); + Item.Values.Add('XMM9'); + Item.Values.Add('XMM10'); + Item.Values.Add('XMM11'); + Item.Values.Add('XMM12'); + Item.Values.Add('XMM13'); + Item.Values.Add('XMM14'); + Item.Values.Add('XMM15'); + + //Item.Values.Add('[RIP]'); + //Item.Values.Add('[RIP + 16]'); + + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else + begin + MemRegBaseIndexCombi(sl_Prefix, FReg32Base, FReg32Index, Item.Values); + end; + end + else if AnsiSameText(sl_Operand, 'XMMRM16') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otXMMRM16; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'word '; + + Item.Values.Add('XMM0'); + Item.Values.Add('XMM1'); + Item.Values.Add('XMM2'); + Item.Values.Add('XMM3'); + Item.Values.Add('XMM4'); + Item.Values.Add('XMM5'); + Item.Values.Add('XMM6'); + Item.Values.Add('XMM7'); + + if x64 then + begin + Item.Values.Add('XMM8'); + Item.Values.Add('XMM9'); + Item.Values.Add('XMM10'); + Item.Values.Add('XMM11'); + Item.Values.Add('XMM12'); + Item.Values.Add('XMM13'); + Item.Values.Add('XMM14'); + Item.Values.Add('XMM15'); + + //Item.Values.Add('[RIP]'); + //Item.Values.Add('[RIP + 16]'); + + MemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else + begin + MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end; + end + else if AnsiSameText(sl_Operand, 'YMMREG') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otYMMReg; + Item.OpActive := true; + + Item.Values.Add('YMM0'); + Item.Values.Add('YMM1'); + Item.Values.Add('YMM2'); + Item.Values.Add('YMM3'); + Item.Values.Add('YMM4'); + Item.Values.Add('YMM5'); + Item.Values.Add('YMM6'); + Item.Values.Add('YMM7'); + + if x64 then + begin + if aOp4 <> 'YMMREG' then + begin + Item.Values.Add('YMM8'); + Item.Values.Add('YMM9'); + Item.Values.Add('YMM10'); + Item.Values.Add('YMM11'); + Item.Values.Add('YMM12'); + Item.Values.Add('YMM13'); + Item.Values.Add('YMM14'); + Item.Values.Add('YMM15'); + end + else + begin + Item.Values.Clear; + + Item.Values.Add('YMM0'); + Item.Values.Add('YMM7'); + Item.Values.Add('YMM8'); + Item.Values.Add('YMM15'); + end; + end; + end + else if AnsiSameText(sl_Operand, 'YMMRM') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otYMMRM; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'yword '; + + Item.Values.Add('YMM0'); + Item.Values.Add('YMM1'); + Item.Values.Add('YMM2'); + Item.Values.Add('YMM3'); + Item.Values.Add('YMM4'); + Item.Values.Add('YMM5'); + Item.Values.Add('YMM6'); + Item.Values.Add('YMM7'); + + if x64 then + begin + Item.Values.Add('YMM8'); + Item.Values.Add('YMM9'); + Item.Values.Add('YMM10'); + Item.Values.Add('YMM11'); + Item.Values.Add('YMM12'); + Item.Values.Add('YMM13'); + Item.Values.Add('YMM14'); + Item.Values.Add('YMM15'); + + MemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else + begin + MemRegBaseIndexCombi(sl_Prefix, FReg32Base, FReg32Index, Item.Values); + end; + end + else if AnsiSameText(sl_Operand, 'MEM8') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otMEM8; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'byte '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'MEM16') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otMEM16; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'word '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_Prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'MEM32') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otMEM32; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'dword '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'MEM64') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otMEM64; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'qword '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'MEM128') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otMEM128; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'oword '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'MEM256') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otMEM256; + Item.OpActive := true; + + if UsePrefix then sl_Prefix := 'yword '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'REG32') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otREG32; + Item.OpActive := true; + + if x64 then + begin + Item.Values.AddStrings(FReg32Base); + end + else Item.Values.AddStrings(FReg32Base); + end + else if AnsiSameText(sl_Operand, 'REG64') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otREG64; + Item.OpActive := true; + + if x64 then + begin + Item.Values.AddStrings(FReg64Base); + end; + end + else if AnsiSameText(sl_Operand, 'RM32') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otRM32; + Item.OpActive := true; + + Item.Values.AddStrings(FReg32Base); + + if UsePrefix then sl_Prefix := 'dword '; + + if x64 then + begin + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'RM64') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otRM32; + Item.OpActive := true; + + + + if UsePrefix then sl_Prefix := 'qword '; + + if x64 then + begin + Item.Values.AddStrings(FReg64Base); + MemRegBaseIndexCombi(sl_Prefix, FReg64Base, FReg64Index, Item.Values); + //MemRegBaseIndexCombi(FReg6432Base, FReg6432Index, Item.Values); + end + else MemRegBaseIndexCombi(sl_prefix, FReg32Base, FReg32Index, Item.Values); + end + else if AnsiSameText(sl_Operand, 'IMM8') then + begin + Item.OpNumber := il_Op; + Item.OpTyp := otIMM8; + Item.OpActive := true; + + Item.Values.Add('0'); + end + else + begin + Item.OpNumber := il_Op; + Item.OpTyp := otUnknown; + Item.OpActive := false; + + Item.Values.Add(''); + end; + end; + + sl_RegCombi := ''; + + + il_Operands := 0; + UsedParams := 0; + + if OItem1.OpActive then + begin + inc(il_Operands); + UsedParams := UsedParams or 1; + end; + + if OItem2.OpActive then + begin + inc(il_Operands); + UsedParams := UsedParams or 2; + end; + + if OItem3.OpActive then + begin + inc(il_Operands); + UsedParams := UsedParams or 4; + end; + + if OItem4.OpActive then + begin + inc(il_Operands); + UsedParams := UsedParams or 8; + end; + + case il_Operands of + 1: UseDefault := UsedParams <> 1; + 2: UseDefault := UsedParams <> 3; + 3: UseDefault := UsedParams <> 7; + 4: UseDefault := UsedParams <> 15; + else UseDefault := true; + end; + + //UseDefault := true; + + if UseDefault then + begin + sl_Inst := format('%-20s', [aInst]); + + for il_Op1 := 0 to OItem1.Values.Count - 1 do + begin + for il_Op2 := 0 to OItem2.Values.Count - 1 do + begin + for il_Op3 := 0 to OItem3.Values.Count - 1 do + begin + for il_Op4 := 0 to OItem4.Values.Count - 1 do + begin + sl_RegCombi := ''; + + if OItem1.OpActive then + begin + if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', '; + sl_RegCombi := sl_RegCombi + OItem1.Values[il_Op1]; + end; + + if OItem2.OpActive then + begin + if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', '; + sl_RegCombi := sl_RegCombi + OItem2.Values[il_Op2]; + end; + + if OItem3.OpActive then + begin + if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', '; + sl_RegCombi := sl_RegCombi + OItem3.Values[il_Op3]; + end; + + if OItem4.OpActive then + begin + if sl_RegCombi <> '' then sl_RegCombi := sl_RegCombi + ', '; + sl_RegCombi := sl_RegCombi + OItem4.Values[il_Op4]; + end; + + if sl_RegCombi <> '' then + begin + //result.Add(format('%-20s%s', [aInst, sl_RegCombi])); + result.Add(sl_Inst + sl_RegCombi); + sl_RegCombi := ''; + end; + end; + end; + end; + end; + end + else + begin + sl_Inst := format('%-20s', [aInst]); + + for il_Op1 := 0 to OItem1.Values.Count - 1 do + begin + if OItem1.OpActive then + begin + sl_RegCombi1 := OItem1.Values[il_Op1]; + end + else sl_RegCombi1 := ''; + + for il_Op2 := 0 to OItem2.Values.Count - 1 do + begin + if OItem2.OpActive then + begin + sl_RegCombi2 := sl_RegCombi1 + ', ' + OItem2.Values[il_Op2]; + end + else sl_RegCombi2 := sl_RegCombi1; + + for il_Op3 := 0 to OItem3.Values.Count - 1 do + begin + if OItem3.OpActive then + begin + sl_RegCombi3 := sl_RegCombi2 + ', ' + OItem3.Values[il_Op3]; + end + else sl_RegCombi3 := sl_RegCombi2; + + for il_Op4 := 0 to OItem4.Values.Count - 1 do + begin + if OItem4.OpActive then + begin + sl_RegCombi := sl_RegCombi3 + ', ' + OItem4.Values[il_Op4]; + end + else sl_RegCombi := sl_RegCombi3; + + if sl_RegCombi <> '' then + begin + //result.Add(format('%-20s%s', [aInst, sl_RegCombi])); + result.Add(sl_Inst + sl_RegCombi); + sl_RegCombi := ''; + end; + end; + end; + end; + end; + end; + finally + FreeAndNil(OItem4); + end; + finally + FreeAndNil(OItem3); + end; + finally + FreeAndNil(OItem2); + end; + finally + FreeAndNil(OItem1); + end; +end; + +constructor TAsmTestGenerator.Create; +begin + inherited; + + FX64 := true; + + FReg32Base := TStringList.Create; + FReg32Index := TStringList.Create; + FReg64Base := TStringList.Create; + FReg64Index := TStringList.Create; + FReg6432Base := TStringList.Create; + FReg6432Index := TStringList.Create; + + FReg32Base.Add('EAX'); + FReg32Base.Add('EBX'); + FReg32Base.Add('ECX'); + FReg32Base.Add('EDX'); + FReg32Base.Add('ESP'); + FReg32Base.Add('EBP'); + FReg32Base.Add('EDI'); + FReg32Base.Add('ESI'); + + + FReg32Index.Add('EAX'); + FReg32Index.Add('EBX'); + FReg32Index.Add('ECX'); + FReg32Index.Add('EDX'); + FReg32Index.Add('EBP'); + FReg32Index.Add('EDI'); + FReg32Index.Add('ESI'); + + + FReg64Base.Add('RAX'); + FReg64Base.Add('RBX'); + FReg64Base.Add('RCX'); + FReg64Base.Add('RDX'); + FReg64Base.Add('RSP'); + FReg64Base.Add('RBP'); + FReg64Base.Add('RDI'); + FReg64Base.Add('RSI'); + FReg64Base.Add('R8'); + FReg64Base.Add('R9'); + FReg64Base.Add('R10'); + FReg64Base.Add('R11'); + FReg64Base.Add('R12'); + FReg64Base.Add('R13'); + FReg64Base.Add('R14'); + FReg64Base.Add('R15'); + + FReg64Index.Add('RAX'); + FReg64Index.Add('RBX'); + FReg64Index.Add('RCX'); + FReg64Index.Add('RDX'); + FReg64Index.Add('RBP'); + FReg64Index.Add('RDI'); + FReg64Index.Add('RSI'); + FReg64Index.Add('R8'); + FReg64Index.Add('R9'); + FReg64Index.Add('R10'); + FReg64Index.Add('R11'); + FReg64Index.Add('R12'); + FReg64Index.Add('R13'); + FReg64Index.Add('R14'); + FReg64Index.Add('R15'); + + FReg6432Base.Add('EAX'); + FReg6432Base.Add('EBX'); + FReg6432Base.Add('ECX'); + FReg6432Base.Add('EDX'); + FReg6432Base.Add('ESP'); + FReg6432Base.Add('EBP'); + FReg6432Base.Add('EDI'); + FReg6432Base.Add('ESI'); + FReg6432Base.Add('R8D'); + FReg6432Base.Add('R9D'); + FReg6432Base.Add('R10D'); + FReg6432Base.Add('R11D'); + FReg6432Base.Add('R12D'); + FReg6432Base.Add('R13D'); + FReg6432Base.Add('R14D'); + FReg6432Base.Add('R15D'); + + FReg6432Index.Add('EAX'); + FReg6432Index.Add('EBX'); + FReg6432Index.Add('ECX'); + FReg6432Index.Add('EDX'); + FReg6432Index.Add('EBP'); + FReg6432Index.Add('EDI'); + FReg6432Index.Add('ESI'); + FReg6432Index.Add('R8D'); + FReg6432Index.Add('R9D'); + FReg6432Index.Add('R10D'); + FReg6432Index.Add('R11D'); + FReg6432Index.Add('R12D'); + FReg6432Index.Add('R13D'); + FReg6432Index.Add('R14D'); + FReg6432Index.Add('R15D'); +end; + +destructor TAsmTestGenerator.Destroy; +begin + FreeAndNil(FReg32Base); + FreeAndNil(FReg32Index); + FreeAndNil(FReg64Base); + FreeAndNil(FReg64Index); + FreeAndNil(FReg6432Base); + FreeAndNil(FReg6432Index); + + inherited; +end; + +procedure TAsmTestGenerator.MemRegBaseIndexCombi(const aPrefix: String; aSLBaseReg, + aSLIndexReg, aRList: TStringList); +var + il_Base: integer; + il_Index: integer; +begin + + for il_Base := 0 to aSLBaseReg.Count - 1 do + begin + aRList.Add(format(aPrefix + '[%s]', [aSLBaseReg[il_Base]])); + + for il_Index := 0 to aSLIndexReg.Count - 1 do + begin + aRList.Add(format(aPrefix + '[%s + %s]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + + aRList.Add(format(aPrefix + '[%s + %s * 2]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + aRList.Add(format(aPrefix + '[%s + %s * 4]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + aRList.Add(format(aPrefix + '[%s + %s * 8]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + + aRList.Add(format(aPrefix + '[%s + %s * 2 + 16]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + aRList.Add(format(aPrefix + '[%s + %s * 4 + 32]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + aRList.Add(format(aPrefix + '[%s + %s * 8 + 48]', [aSLBaseReg[il_Base], aSLIndexReg[il_Index]])); + end; + end; +end; + +class procedure TAsmTestGenerator.CalcTestData(aX64: boolean; const aInst, aOp1, aOp2, aOp3, + aOp4: String; aSL: TStringList); +var + sl: TStringList; +begin + with TAsmTestGenerator.Create do + try + Fx64 := aX64; + + sl := InternalCalcTestData(aInst, aOp1, aOp2, aOp3, aOp4); + try + aSL.AddStrings(sl); + finally + FreeAndNil(sl); + end; + finally + Free; + end; +end; + +end. diff --git a/tests/utils/avx/avxopcodes.pas b/tests/utils/avx/avxopcodes.pas new file mode 100644 index 0000000000..cdc9c77b1c --- /dev/null +++ b/tests/utils/avx/avxopcodes.pas @@ -0,0 +1,648 @@ +{$mode objfpc} + +unit avxopcodes; + +interface + +uses Classes; + +type + + TTestFileTyp = (tfNasm, tfFPC); + + TAVXTestGenerator = class(TObject) + private + FOpCodeList: TStringList; + protected + procedure Init; + + function InternalMakeTestFiles(aX64: boolean; aDestPath, aFileExt: String; aOpCodeList, aHeaderList, aFooterList: TStringList): boolean; + + public + constructor Create; + destructor Destroy; override; + + function MakeTestFiles(aTyp: TTestFileTyp; aX64: boolean; aDestPath: String): boolean; + + property OpCodeList: TStringList read FOpCodeList write FOpCodeList; + end; + +implementation + +uses SysUtils, AsmTestGenerator; + +{ TAVXTestGenerator } + +constructor TAVXTestGenerator.Create; +begin + inherited; + + FOpCodeList := TStringList.Create; + + Init; +end; + +destructor TAVXTestGenerator.Destroy; +begin + FreeAndNil(FOpCodeList); + + inherited; +end; + +procedure TAVXTestGenerator.Init; +begin + FOpCodeList.Add('VADDPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VADDPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VADDPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VADDPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VADDSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VADDSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VADDSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VADDSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VADDSUBPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VADDSUBPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VADDSUBPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VADDSUBPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VAESDEC,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VAESDECLAST,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VAESENC,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VAESENCLAST,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VAESIMC,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VAESKEYGENASSIST,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VANDNPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VANDNPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VANDNPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VANDNPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VANDPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VANDPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VANDPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VANDPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VBLENDPD,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VBLENDPD,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VBLENDPS,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VBLENDPS,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VBLENDVPD,1,1,XMMREG,XMMREG,XMMRM,XMMREG'); + FOpCodeList.Add('VBLENDVPD,1,1,YMMREG,YMMREG,YMMRM,YMMREG'); + FOpCodeList.Add('VBLENDVPS,1,1,XMMREG,XMMREG,XMMRM,XMMREG'); + FOpCodeList.Add('VBLENDVPS,1,1,YMMREG,YMMREG,YMMRM,YMMREG'); + FOpCodeList.Add('VBROADCASTF128,1,1,YMMREG,MEM128,,'); + FOpCodeList.Add('VBROADCASTSD,1,1,YMMREG,MEM64,,'); + FOpCodeList.Add('VBROADCASTSS,1,1,YMMREG,MEM32,,'); + FOpCodeList.Add('VBROADCASTSS,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VCMPPD,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VCMPPD,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VCMPPS,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VCMPPS,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VCMPSD,1,1,XMMREG,XMMREG,MEM64,IMM8'); + FOpCodeList.Add('VCMPSD,1,1,XMMREG,XMMREG,XMMREG,IMM8'); + FOpCodeList.Add('VCMPSS,1,1,XMMREG,XMMREG,MEM64,IMM8'); + FOpCodeList.Add('VCMPSS,1,1,XMMREG,XMMREG,XMMREG,IMM8'); + FOpCodeList.Add('VCOMISD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VCOMISD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VCOMISS,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VCOMISS,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VCVTDQ2PD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VCVTDQ2PD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VCVTDQ2PD,1,1,YMMREG,YMMREG,,'); + FOpCodeList.Add('VCVTDQ2PD,1,1,YMMREG,MEM128,,'); + FOpCodeList.Add('VCVTDQ2PS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTDQ2PS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VCVTPD2DQ,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTPD2DQ,1,1,XMMREG,YMMRM,,'); + FOpCodeList.Add('VCVTPD2PS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTPD2PS,1,1,XMMREG,YMMRM,,'); + FOpCodeList.Add('VCVTPS2DQ,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTPS2DQ,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VCVTPS2PD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VCVTPS2PD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VCVTPS2PD,1,1,YMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTSD2SI,1,1,REG32,MEM64,,'); + FOpCodeList.Add('VCVTSD2SI,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VCVTSD2SI,0,1,REG64,MEM64,,'); + FOpCodeList.Add('VCVTSD2SI,0,1,REG64,XMMREG,,'); + FOpCodeList.Add('VCVTSD2SS,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VCVTSD2SS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VCVTSI2SD,1,1,XMMREG,XMMREG,RM32,'); + FOpCodeList.Add('VCVTSI2SD,0,1,XMMREG,XMMREG,RM64,'); + FOpCodeList.Add('VCVTSI2SS,1,1,XMMREG,XMMREG,RM32,'); + FOpCodeList.Add('VCVTSI2SS,0,1,XMMREG,XMMREG,RM64,'); + FOpCodeList.Add('VCVTSS2SD,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VCVTSS2SD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VCVTSS2SI,1,1,REG32,MEM32,,'); + FOpCodeList.Add('VCVTSS2SI,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VCVTSS2SI,0,1,REG64,MEM32,,'); + FOpCodeList.Add('VCVTSS2SI,0,1,REG64,XMMREG,,'); + FOpCodeList.Add('VCVTTPD2DQ,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTTPD2DQ,1,1,XMMREG,YMMRM,,'); + FOpCodeList.Add('VCVTTPS2DQ,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VCVTTPS2DQ,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VCVTTSD2SI,1,1,REG32,MEM64,,'); + FOpCodeList.Add('VCVTTSD2SI,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VCVTTSD2SI,0,1,REG64,MEM64,,'); + FOpCodeList.Add('VCVTTSD2SI,0,1,REG64,XMMREG,,'); + FOpCodeList.Add('VCVTTSS2SI,1,1,REG32,MEM32,,'); + FOpCodeList.Add('VCVTTSS2SI,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VCVTTSS2SI,0,1,REG64,MEM32,,'); + FOpCodeList.Add('VCVTTSS2SI,0,1,REG64,XMMREG,,'); + FOpCodeList.Add('VDIVPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VDIVPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VDIVPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VDIVPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VDIVSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VDIVSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VDIVSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VDIVSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VDPPD,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VDPPS,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VDPPS,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VEXTRACTF128,1,1,XMMRM,YMMREG,IMM8,'); + FOpCodeList.Add('VEXTRACTPS,1,1,RM32,XMMREG,IMM8,'); + FOpCodeList.Add('VHADDPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VHADDPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VHADDPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VHADDPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VHSUBPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VHSUBPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VHSUBPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VHSUBPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VINSERTF128,1,1,YMMREG,YMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VINSERTPS,1,1,XMMREG,XMMREG,MEM32,IMM8'); + FOpCodeList.Add('VINSERTPS,1,1,XMMREG,XMMREG,XMMREG,IMM8'); + FOpCodeList.Add('VLDDQU,1,1,XMMREG,MEM128,,'); + FOpCodeList.Add('VLDDQU,1,1,YMMREG,MEM256,,'); + FOpCodeList.Add('VLDMXCSR,1,1,MEM32,,,'); + FOpCodeList.Add('VMASKMOVDQU,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VMASKMOVPD,1,1,MEM256,YMMREG,YMMREG,'); + FOpCodeList.Add('VMASKMOVPD,1,1,MEM128,XMMREG,XMMREG,'); + FOpCodeList.Add('VMASKMOVPD,1,1,YMMREG,YMMREG,MEM256,'); + FOpCodeList.Add('VMASKMOVPD,1,1,XMMREG,XMMREG,MEM128,'); + FOpCodeList.Add('VMASKMOVPS,1,1,MEM256,YMMREG,YMMREG,'); + FOpCodeList.Add('VMASKMOVPS,1,1,MEM128,XMMREG,XMMREG,'); + FOpCodeList.Add('VMASKMOVPS,1,1,YMMREG,YMMREG,MEM256,'); + FOpCodeList.Add('VMASKMOVPS,1,1,XMMREG,XMMREG,MEM128,'); + FOpCodeList.Add('VMAXPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VMAXPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VMAXPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VMAXPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VMAXSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMAXSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMAXSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VMAXSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMINPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VMINPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VMINPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VMINPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VMINSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMINSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMINSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VMINSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVAPD,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVAPD,1,1,XMMRM,XMMREG,,'); + FOpCodeList.Add('VMOVAPD,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVAPD,1,1,YMMRM,YMMREG,,'); + FOpCodeList.Add('VMOVAPS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVAPS,1,1,XMMRM,XMMREG,,'); + FOpCodeList.Add('VMOVAPS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVAPS,1,1,YMMRM,YMMREG,,'); + FOpCodeList.Add('VMOVD,1,1,XMMREG,RM32,,'); + FOpCodeList.Add('VMOVD,1,1,RM32,XMMREG,,'); + FOpCodeList.Add('VMOVDDUP,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVDDUP,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VMOVDDUP,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VMOVDQA,1,1,YMMRM,YMMREG,,'); + FOpCodeList.Add('VMOVDQA,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVDQA,1,1,XMMRM,XMMREG,,'); + FOpCodeList.Add('VMOVDQA,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVDQU,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVDQU,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVDQU,1,1,XMMRM,XMMREG,,'); + FOpCodeList.Add('VMOVDQU,1,1,YMMRM,YMMREG,,'); + FOpCodeList.Add('VMOVHLPS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVHPD,1,1,MEM64,XMMREG,,'); + FOpCodeList.Add('VMOVHPD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMOVHPS,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMOVHPS,1,1,MEM64,XMMREG,,'); + FOpCodeList.Add('VMOVLHPS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVLPD,1,1,MEM64,XMMREG,,'); + FOpCodeList.Add('VMOVLPD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMOVLPS,1,1,MEM64,XMMREG,,'); + FOpCodeList.Add('VMOVLPS,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMOVMSKPD,1,1,REG32,YMMREG,,'); + FOpCodeList.Add('VMOVMSKPD,1,1,REG64,XMMREG,,'); + FOpCodeList.Add('VMOVMSKPD,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VMOVMSKPD,1,1,REG64,YMMREG,,'); + FOpCodeList.Add('VMOVMSKPS,1,1,REG32,YMMREG,,'); + FOpCodeList.Add('VMOVMSKPS,1,1,REG64,XMMREG,,'); + FOpCodeList.Add('VMOVMSKPS,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VMOVMSKPS,1,1,REG64,YMMREG,,'); + FOpCodeList.Add('VMOVNTDQ,1,1,MEM128,XMMREG,,'); + FOpCodeList.Add('VMOVNTDQ,1,1,MEM256,YMMREG,,'); + FOpCodeList.Add('VMOVNTDQA,1,1,XMMREG,MEM128,,'); + FOpCodeList.Add('VMOVNTPD,1,1,MEM256,YMMREG,,'); + FOpCodeList.Add('VMOVNTPD,1,1,MEM128,XMMREG,,'); + FOpCodeList.Add('VMOVNTPS,1,1,MEM128,YMMREG,,'); + FOpCodeList.Add('VMOVNTPS,1,1,MEM128,XMMREG,,'); + FOpCodeList.Add('VMOVQ,0,1,RM64,XMMREG,,'); + FOpCodeList.Add('VMOVQ,0,1,XMMREG,RM64,,'); + FOpCodeList.Add('VMOVSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVSD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VMOVSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVSD,1,1,MEM64,XMMREG,,'); + FOpCodeList.Add('VMOVSHDUP,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVSHDUP,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVSLDUP,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVSLDUP,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVSS,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VMOVSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMOVSS,1,1,MEM64,XMMREG,,'); + FOpCodeList.Add('VMOVUPD,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVUPD,1,1,XMMRM,XMMREG,,'); + FOpCodeList.Add('VMOVUPD,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVUPD,1,1,YMMRM,YMMREG,,'); + FOpCodeList.Add('VMOVUPS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VMOVUPS,1,1,XMMRM,XMMREG,,'); + FOpCodeList.Add('VMOVUPS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VMOVUPS,1,1,YMMRM,YMMREG,,'); + FOpCodeList.Add('VMPSADBW,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VMULPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VMULPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VMULPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VMULPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VMULSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VMULSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VMULSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VMULSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VORPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VORPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VORPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VPABSB,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VPABSD,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VPABSW,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VPACKSSDW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPACKSSWB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPACKUSDW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPACKUSWB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDSB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDUSB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDUSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPADDW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPALIGNR,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VPAND,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPANDN,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPAVGB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPAVGW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPBLENDVB,1,1,XMMREG,XMMREG,XMMRM,XMMREG'); + FOpCodeList.Add('VPBLENDW,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VPCLMULQDQ,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VPCMPEQB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPEQD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPEQQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPEQW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPESTRI,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPCMPESTRM,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPCMPGTB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPGTD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPGTQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPGTW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPCMPISTRI,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPCMPISTRM,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPERM2F128,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VPERMILPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VPERMILPD,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPERMILPD,1,1,YMMREG,YMMRM,IMM8,'); + FOpCodeList.Add('VPERMILPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPERMILPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VPERMILPS,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPERMILPS,1,1,YMMREG,YMMRM,IMM8,'); + FOpCodeList.Add('VPERMILPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPEXTRB,1,1,REG32,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRB,1,1,REG64,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRB,1,1,MEM8,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRD,1,1,RM32,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRQ,0,1,RM64,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRW,1,1,REG32,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRW,1,1,REG64,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRW,1,1,REG64,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRW,1,1,MEM16,XMMREG,IMM8,'); + FOpCodeList.Add('VPEXTRW,1,1,REG32,XMMREG,IMM8,'); + FOpCodeList.Add('VPHADDD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPHADDSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPHADDW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPHMINPOSUW,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VPHSUBD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPHSUBSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPHSUBW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPINSRB,1,1,XMMREG,XMMREG,REG32,IMM8'); + FOpCodeList.Add('VPINSRB,1,1,XMMREG,XMMREG,MEM8,IMM8'); + FOpCodeList.Add('VPINSRD,1,1,XMMREG,XMMREG,RM32,IMM8'); + FOpCodeList.Add('VPINSRQ,0,1,XMMREG,XMMREG,RM64,IMM8'); + FOpCodeList.Add('VPINSRW,1,1,XMMREG,XMMREG,REG32,IMM8'); + FOpCodeList.Add('VPINSRW,1,1,XMMREG,XMMREG,MEM16,IMM8'); + FOpCodeList.Add('VPMADDUBSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMADDWD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMAXSB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMAXSD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMAXSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMAXUB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMAXUD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMAXUW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMINSB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMINSD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMINSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMINUB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMINUD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMINUW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMOVMSKB,1,1,REG64,XMMREG,,'); + FOpCodeList.Add('VPMOVMSKB,1,1,REG32,XMMREG,,'); + FOpCodeList.Add('VPMOVSXBD,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VPMOVSXBD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVSXBQ,1,1,XMMREG,MEM16,,'); + FOpCodeList.Add('VPMOVSXBQ,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVSXBW,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VPMOVSXBW,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVSXDQ,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VPMOVSXDQ,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVSXWD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VPMOVSXWD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVSXWQ,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VPMOVSXWQ,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVZXBD,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VPMOVZXBD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVZXBQ,1,1,XMMREG,MEM16,,'); + FOpCodeList.Add('VPMOVZXBQ,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVZXBW,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VPMOVZXBW,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVZXDQ,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VPMOVZXDQ,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVZXWD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VPMOVZXWD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMOVZXWQ,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VPMOVZXWQ,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VPMULDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMULHRSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMULHUW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMULHW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMULLD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMULLW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPMULUDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPOR,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSADBW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSHUFB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSHUFD,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPSHUFHW,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPSHUFLW,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VPSIGNB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSIGND,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSIGNW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSLLD,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSLLD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSLLDQ,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSLLQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSLLQ,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSLLW,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSLLW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSRAD,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSRAD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSRAW,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSRAW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSRLD,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSRLD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSRLDQ,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSRLQ,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSRLQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSRLW,1,1,XMMREG,XMMREG,IMM8,'); + FOpCodeList.Add('VPSRLW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBSB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBUSB,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBUSW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPSUBW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPTEST,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VPTEST,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VPUNPCKHBW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKHDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKHQDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKHWD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKLBW,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKLDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKLQDQ,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPUNPCKLWD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VPXOR,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VRCPPS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VRCPPS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VRCPSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VRCPSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VROUNDPD,1,1,YMMREG,YMMRM,IMM8,'); + FOpCodeList.Add('VROUNDPD,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VROUNDPS,1,1,YMMREG,YMMRM,IMM8,'); + FOpCodeList.Add('VROUNDPS,1,1,XMMREG,XMMRM,IMM8,'); + FOpCodeList.Add('VROUNDSD,1,1,XMMREG,XMMREG,MEM64,IMM8'); + FOpCodeList.Add('VROUNDSD,1,1,XMMREG,XMMREG,XMMREG,IMM8'); + FOpCodeList.Add('VROUNDSS,1,1,XMMREG,XMMREG,MEM32,IMM8'); + FOpCodeList.Add('VROUNDSS,1,1,XMMREG,XMMREG,XMMREG,IMM8'); + FOpCodeList.Add('VRSQRTPS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VRSQRTPS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VRSQRTSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VRSQRTSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VSHUFPD,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VSHUFPD,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VSHUFPS,1,1,XMMREG,XMMREG,XMMRM,IMM8'); + FOpCodeList.Add('VSHUFPS,1,1,YMMREG,YMMREG,YMMRM,IMM8'); + FOpCodeList.Add('VSQRTPD,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VSQRTPD,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VSQRTPS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VSQRTPS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VSQRTSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VSQRTSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VSQRTSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VSQRTSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VSTMXCSR,1,1,MEM32,,,'); + FOpCodeList.Add('VSUBPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VSUBPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VSUBPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VSUBPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VSUBSD,1,1,XMMREG,XMMREG,MEM64,'); + FOpCodeList.Add('VSUBSD,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VSUBSS,1,1,XMMREG,XMMREG,MEM32,'); + FOpCodeList.Add('VSUBSS,1,1,XMMREG,XMMREG,XMMREG,'); + FOpCodeList.Add('VTESTPD,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VTESTPD,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VTESTPS,1,1,YMMREG,YMMRM,,'); + FOpCodeList.Add('VTESTPS,1,1,XMMREG,XMMRM,,'); + FOpCodeList.Add('VUCOMISD,1,1,XMMREG,MEM64,,'); + FOpCodeList.Add('VUCOMISD,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VUCOMISS,1,1,XMMREG,MEM32,,'); + FOpCodeList.Add('VUCOMISS,1,1,XMMREG,XMMREG,,'); + FOpCodeList.Add('VUNPCKHPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VUNPCKHPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VUNPCKHPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VUNPCKHPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VUNPCKLPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VUNPCKLPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VUNPCKLPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VUNPCKLPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VXORPD,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VXORPD,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VXORPS,1,1,XMMREG,XMMREG,XMMRM,'); + FOpCodeList.Add('VXORPS,1,1,YMMREG,YMMREG,YMMRM,'); + FOpCodeList.Add('VZEROALL,1,1,,,,'); + FOpCodeList.Add('VZEROUPPER,1,1,,,,'); +end; + +function TAVXTestGenerator.InternalMakeTestFiles(aX64: boolean; aDestPath, aFileExt: String; + aOpCodeList, aHeaderList, aFooterList: TStringList): boolean; +var + i: integer; + sl: TStringList; + slAsm: TStringList; + LastOpCode: String; + NewOpCode: String; + + function SaveFile(aAsmList: TStringList; aOpcode, aDestPath, aFileExt: String; aHeaderList, aFooterList: TStringList): boolean; + begin + result := false; + + if aAsmList.Count > 0 then + begin + aAsmList.Insert(0, StringReplace(aHeaderList.Text, '$$$OPCODE$$$', aOpCode, [])); + aAsmList.AddStrings(aFooterList); + + aAsmList.SaveToFile(IncludeTrailingBackslash(aDestPath) + aOpCode + aFileExt); + end; + end; + +begin + result := false; + + aOpCodeList.Sort; + + sl := TStringList.Create; + try + slAsm := TStringList.Create; + try + LastOpCode := ''; + + for i := 0 to aOpCodeList.Count - 1 do + //for i := 0 to 0 do + begin + sl.Clear; + sl.CommaText := aOpCodeList[i]; + + while sl.Count < 7 do sl.Add(''); + + NewOpCode := sl[0]; + if NewOpCode <> '' then + begin + if NewOpCode <> LastOpCode then + begin + if LastOpCode <> '' then + begin + SaveFile(slAsm, LastOpCode, aDestPath, aFileExt, aHeaderList, aFooterList); + writeln(format('%s%s%s', [aDestPath, NewOpCode, aFileExt])); + + slAsm.Clear; + LastOpCode := NewOpCode; + end + else LastOpCode := NewOpCode; + end; + + if (not(aX64) and (sl[1] = '1')) or // i386 + (aX64 and (sl[2] = '1')) then // x86_64 + begin + if (sl[3] = '') and + (sl[3] = '') and + (sl[3] = '') and + (sl[3] = '') then + begin // Opcode with no Params, e.g. VZEROALL + slAsm.Add(' ' + sl[0]); + end + else TAsmTestGenerator.CalcTestData(aX64, sl[0], sl[3], sl[4], sl[5], sl[6], slAsm); + end; + end; + end; + + if NewOpCode <> '' then + begin + SaveFile(slAsm, NewOpCode, aDestPath, aFileExt, aHeaderList, aFooterList); + writeln(format('%s%s%s', [aDestPath, NewOpCode, aFileExt])); + end; + + finally + FreeAndNil(slAsm); + end; + finally + FreeAndNil(sl); + end; +end; + +function TAVXTestGenerator.MakeTestFiles(aTyp: TTestFileTyp; aX64: boolean; + aDestPath: String): boolean; +var + slHeader: TStringList; + slFooter: TStringList; + FileExt: String; + i: integer; +const + cPlatform: array[boolean] of String = (('i386'), ('x86_64')); +begin + result := false; + + slHeader := TStringList.Create; + try + slFooter := TStringList.Create; + try + case aTyp of + tfFPC: begin + writeln(format('outputformat: fpc platform: %s path: %s', + [cPlatform[aX64], aDestPath])); + + FileExt := '.pp'; + + slHeader.Add('Program $$$OPCODE$$$;'); + slHeader.Add('{$asmmode intel}'); + slHeader.Add('begin'); + slHeader.Add(' asm'); + + for i := 1 to 10 do + slHeader.Add('NOP'); + + for i := 1 to 10 do + slFooter.Add('NOP'); + + slFooter.Add(' end;'); + slFooter.Add('end.'); + end; + tfNasm: begin + writeln(format('outputformat: fpc platform: %s path: %s', + [cPlatform[aX64], aDestPath])); + + FileExt := '.asm'; + + for i := 1 to 10 do + slHeader.Add('NOP'); + + for i := 1 to 10 do + slFooter.Add('NOP'); + end; + end; + + InternalMakeTestFiles(aX64, aDestPath, Fileext, FOpCodeList, slHeader, slFooter); + + finally + FreeAndNil(slFooter); + end; + finally + FreeAndNil(slHeader); + end; +end; + +end. + diff --git a/tests/utils/avx/avxtestfilecmp.pp b/tests/utils/avx/avxtestfilecmp.pp new file mode 100644 index 0000000000..dd4d7d8a58 --- /dev/null +++ b/tests/utils/avx/avxtestfilecmp.pp @@ -0,0 +1,74 @@ +program avxtestfilecmp; +{$mode objfpc} +uses + sysutils, + filecomparer in 'filecomparer.pas', + cmpoptions in 'cmpoptions.pas'; + +var + ch: Char; + sm: String; +begin + with TFileComparer.Create do + try + with TOptions.Create do + try + LoadParams; + + if Help then + begin + writeln('avx-testfile-generator 0.1'); + writeln('author: torsten grundke'); + writeln(''); + writeln('compare avx-assembler-testfiles'); + writeln(''); + writeln('-h help'); + writeln('-m sourcefile mask'); + writeln('-n sourcefile extention'); + writeln('-d destination path'); + writeln('-e destinationfile extention'); + writeln('-s silent'); + writeln(''); + {$IFDEF WINDOWS} + writeln('examples: -mc:\tmp\*.obj -dc:\tmp\avx\ -eexe'); + writeln(' -m/tmp/* -n -d/tmp/avx/ -e'); + {$ELSE} + writeln('examples: -m/tmp/*.obj -d/tmp/avx/ -ebin'); + writeln(' -m/tmp/* -n -d/tmp/avx/ -e'); + {$ENDIF} + writeln; + end + else + begin + sm := SourceMask; + + if ExtractFileExt(sm) = '' then + begin + if trim(SourceFileExtention) <> '' then + begin + if copy(SourceFileExtention, 1, 1) <> '.' then sm := sm + '.' + SourceFileExtention + else sm := sm + SourceFileExtention; + end; + end; + + if (ExtractFilePath(sm) = DestPath) and + (DestFileExtention = '') then + begin + writeln(format('Do you want compare the same files (sourcepath: "%s" destination path: "%s"). [Y/N]', + [ExtractFilePath(sm), DestPath])); + + read(ch); + if ch in ['Y', 'y', 'J', 'N'] then CompareFiles(NoSourceFileExtention, NoDestFileExtention, Silent, + sm, DestPath, DestFileExtention); + end + else CompareFiles(NoSourceFileExtention, NoDestFileExtention, Silent, + sm, DestPath, DestFileExtention); + end; + finally + Free; + end; + finally + Free; + end; + +end. diff --git a/tests/utils/avx/avxtestgenerator.pp b/tests/utils/avx/avxtestgenerator.pp new file mode 100644 index 0000000000..1457f9ea99 --- /dev/null +++ b/tests/utils/avx/avxtestgenerator.pp @@ -0,0 +1,63 @@ +{ + + Copyright (C) <avx-testfile-generator> <Torsten Grundke> + + This source is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at your option) + any later version. + + This code 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. + + A copy of the GNU General Public License is available on the World Wide Web + at <http://www.gnu.org/copyleft/gpl.html>. You can also obtain it by writing + to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. +} + +{$mode objfpc} + +program AVXTestGenerator; +uses + sysutils, + AVXOpCodes in 'AVXOpCodes.pas', + AsmTestGenerator in 'AsmTestGenerator.pas', + Options in 'Options.pas'; + +begin + with TAVXTestGenerator.Create do + try + with TOptions.Create do + try + LoadParams; + + if Help then + begin + writeln('avx-testfile-generator 0.1'); + writeln('author: torsten grundke'); + writeln(''); + writeln('make avx assembler-testfiles'); + writeln(''); + writeln('-h help'); + writeln('-f [fpc,nasm] outputformat'); + writeln('-p [x8664] codegenerator for x86_64 platform'); + writeln('-o destination path'); + writeln(''); + end + else + begin + case OutputFormat of + 'f': MakeTestFiles(tfFPC, x64, Path); + 'n': MakeTestFiles(tfNasm, x64, Path); + end; + end; + finally + Free; + end; + finally + Free; + end; +end. diff --git a/tests/utils/avx/baselist.pas b/tests/utils/avx/baselist.pas new file mode 100644 index 0000000000..c9e54207ef --- /dev/null +++ b/tests/utils/avx/baselist.pas @@ -0,0 +1,72 @@ +{ + + Copyright (C) <avx-testfile-generator> <Torsten Grundke> + + This source is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at your option) + any later version. + + This code 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. + + A copy of the GNU General Public License is available on the World Wide Web + at <http://www.gnu.org/copyleft/gpl.html>. You can also obtain it by writing + to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. +} + +{$mode objfpc} + +unit baselist; + +interface + +uses Contnrs, Classes; + +type + + // basisliste + TBaseList = class(TPersistent) + private + + protected + FList: TObjectlist; + public + constructor Create; virtual; + destructor Destroy; override; + function count: integer; + procedure clear; + end; + +implementation + +{ TBaseList } + +uses SysUtils; + +procedure TBaseList.clear; +begin + FList.Clear; +end; + +function TBaseList.count: integer; +begin + result := FList.Count; +end; + +constructor TBaseList.Create; +begin + inherited; + FList := TObjectList.Create; +end; + +destructor TBaseList.Destroy; +begin + FreeAndNil(FList); + inherited; +end; + +end. diff --git a/tests/utils/avx/cmpoptions.pas b/tests/utils/avx/cmpoptions.pas new file mode 100644 index 0000000000..781dafee95 --- /dev/null +++ b/tests/utils/avx/cmpoptions.pas @@ -0,0 +1,137 @@ +unit cmpoptions; + +{$mode objfpc} + +interface + +type + + { TOptions } + + TOptions = class(TObject) + private + FHelp: boolean; + FNoDestFileExtention: boolean; + FNoSourceFileExtention: boolean; + FSilent: boolean; + FSourceFileExtention: String; + FSourceMask: String; + FDestFileExtention: String; + FDestPath: String; + public + constructor Create; + + procedure LoadParams; + + property Help : boolean read FHelp write FHelp; + property SourceMask : String read FSourceMask write FSourceMask; + property SourceFileExtention : String read FSourceFileExtention write FSourceFileExtention; + property NoSourceFileExtention: boolean read FNoSourceFileExtention; + + property DestPath : String read FDestPath write FDestPath; + property DestFileExtention : String read FDestFileExtention write FDestFileExtention; + property NoDestFileExtention : boolean read FNoDestFileExtention; + property Silent : boolean read FSilent; + end; + +implementation + +uses SysUtils; + +{ TOptions } + +constructor TOptions.Create; +begin + FHelp := false; + FSourceMask := ''; + FNoSourceFileExtention := false; + FDestFileExtention := ''; + FDestPath := ''; + FSilent := false; +end; + +procedure TOptions.LoadParams; +var + i: integer; + sParam : Char; + sValue : String; + IsInvalidParam: boolean; +begin + if ParamCount = 0 then FHelp := true + else FHelp := false; + + FSourceMask := IncludeTrailingBackslash(GetCurrentDir) + '*.*'; + FSourceFileExtention := ''; + FNoSourceFileExtention := false; + + FDestPath := IncludeTrailingBackslash(GetCurrentDir); + FDestFileExtention := ''; + FNoDestFileExtention := false; + + FSilent := false; + + for i := 1 to ParamCount do + begin + if copy(ParamStr(i), 1, 1) = '-' then + begin + sParam := copy(ParamStr(i) + ' ', 2, 1)[1]; + sValue := copy(ParamStr(i), 3, length(ParamStr(i))); + + IsInvalidParam := false; + case sParam of + 'h': FHelp := true; + 'm': begin + FSourceMask := sValue; + + if copy(FSourceMask, 1, 2) = '\\' then FSourceMask := ExpandUNCFileName(FSourceMask) + else FSourceMask := ExpandFileName(FSourceMask); + + if ExtractFileName(FSourceMask) = '' then FSourceMask := FSourceMask + '*'; + end; + 'n': begin + FSourceFileExtention := sValue; + FNoSourceFileExtention := FSourceFileExtention = ''; + end; + 'd': begin + FDestPath := sValue; + + if copy(FDestPath, 1, 2) = '\\' then FDestPath := ExpandUNCFileName(FDestPath) + else FDestPath := ExpandFileName(FDestPath); + end; + 'e': begin + FDestFileExtention := sValue; + FNoDestFileExtention := FDestFileExtention = ''; + end; + 's': FSilent := true; + else begin + FHelp := true; + writeln(format('invalid param "%s"', [ParamStr(i)])); + end; + end; + end + else IsInvalidParam := true; + + if (FNoSourceFileExtention = false) and + (FSourceFileExtention = '') then + begin + FSourceFileExtention := ExtractFileExt(FSourceMask); + end + else if (ExtractFileExt(FSourceMask) <> '') and + (FSourceFileExtention <> '') and + (ExtractFileExt(FSourceMask) <> FSourceFileExtention) then + begin + writeln(format('parameter conflict: different sourcefile extention "%s" and "%s"', + [ExtractFileExt(FSourceMask), FSourceFileExtention])); + FHelp := true; + end; + + if IsInvalidParam then + begin + FHelp := true; + writeln(format('invalid param "%s"', [ParamStr(i)])); + end; + end; +end; + + +end. diff --git a/tests/utils/avx/filecomparer.pas b/tests/utils/avx/filecomparer.pas new file mode 100644 index 0000000000..e95d731738 --- /dev/null +++ b/tests/utils/avx/filecomparer.pas @@ -0,0 +1,228 @@ +unit filecomparer; + +{$mode objfpc} + +interface + +uses Classes; + + + +type + TFileComparer = class(TObject) + private + protected + function LoadFromFile(const aFilename: String): TMemoryStream; + + function Compare(const aFileName1, aFilename2: String; var aMsg: String): boolean; + public + procedure CompareFiles(aNoSourcefileExt, aNoDestfileExt, aSilent: boolean; const aSourceMask, aDestPath, aDestFileExtention: String); + end; + + +implementation + +uses SysUtils; + + +{ TFileComparer } + +function TFileComparer.Compare(const aFileName1, + aFilename2: String; var aMsg: String): boolean; +var + MStream1: TMemoryStream; + MStream2: TMemoryStream; +begin + result := false; + aMsg := ''; + + if not(FileExists(aFileName1)) then + begin + aMsg := format('file "%s" not found', [aFileName1]); + end + else if not(FileExists(aFileName1)) then + begin + aMsg := format('file "%s" not found', [aFileName2]); + end + else + begin + MStream1 := LoadFromFile(aFilename1); + try + MStream1.Position := 0; + + MStream2 := LoadFromFile(aFilename2); + try + MStream2.Position := 0; + + if MStream1.Size < 1 then aMsg := format('file "%s": start or endmarker not found', [aFilename1]) + else if MStream2.Size < 1 then aMsg := format('file "%s": start or endmarker not found', [aFilename2]) + else + begin + if MStream1.Size <> MStream2.Size then aMsg := format('diff: file: "%s" size: %d - file: "%s" size: %d', + [aFilename1, MStream1.Size, + aFilename2, MStream2.Size]) + else + begin + if CompareMem(MStream1.Memory, MStream2.Memory, MStream1.Size) then result := true + else aMsg := format('diff: file: "%s" <> file: "%s"', [aFileName1, aFileName2]); + end; + end; + finally + FreeAndNil(MStream2); + end; + finally + FreeAndNil(MStream1); + end; + end; +end; + +procedure TFileComparer.CompareFiles(aNoSourcefileExt, aNoDestfileExt, aSilent: boolean; const aSourceMask, aDestPath, aDestFileExtention: String); +var + i: integer; + sl: TStringList; + sr: TSearchRec; + Path: String; + FileName: String; + SourceFileName: String; + DestFileName: String; + DestFileExtention: String; + Msg: String; +begin + Path := IncludeTrailingBackslash(ExtractFilePath(aSourceMask)); + DestFileExtention := aDestFileExtention; + + if (DestFileExtention <> '') and + (copy(DestFileExtention, 1, 1) <> '.') then + begin + DestFileExtention := '.' + DestFileExtention; + end; + + sl := TStringList.Create; + try + if FindFirst(aSourceMask, faAnyFile - faDirectory - faVolumeID , sr) = 0 then + repeat + if not((aNoSourcefileExt) and (ExtractFileExt(sr.Name) <> '')) then sl.Add(sr.Name); + until FindNext(sr) <> 0; + FindClose(sr); + + for i := 0 to sl.Count - 1 do + begin + sl.Sort; + + if aDestFileExtention <> '' then + begin + FileName := copy(sl[i], 1, length(sl[i]) - length(ExtractFileExt(sl[i]))); + + if FileName = '' then FileName := sl[i]; + end + else + begin + if aNoDestfileExt then + begin + if ExtractFileExt(sl[i]) = '' then Filename := sl[i] + else + begin + FileName := copy(sl[i], 1, length(sl[i]) - length(ExtractFileExt(sl[i]))); + end; + end + else Filename := sl[i]; + end; + + SourceFileName := Path + sl[i]; + DestFileName := IncludeTrailingBackslash(aDestpath) + FileName + DestFileExtention; + + if FileExists(SourceFileName) then + begin + if FileExists(DestFileName) then + begin + if Compare(SourceFileName, DestFileName, Msg) then + begin + if not(aSilent) then writeln(format('compare = equal (source: "%s" destination: "%s")', [SourceFileName, DestFileName])); + end + else if Msg <> '' then writeln(ErrOutPut, Msg); + end + else writeln(ErrOutPut, format('Comparefile "%s" not found', [DestFileName])); + end + else writeln(ErrOutPut, format('Sourcefile "%s" not found', [SourceFileName])); + end; + finally + FreeAndNil(sl); + end; + +end; + +function TFileComparer.LoadFromFile( + const aFilename: String): TMemoryStream; +var + MStream : TMemoryStream; + + StartPos : integer; + EndPos : integer; + + + function FindPos(aStream: TStream; aStartPos: integer; aEndPos: boolean): integer; + var + NopCount : integer; + ch : byte; + begin + result := -1; + + if assigned(aStream) then + begin + aStream.Position := aStartPos; + + NopCount := 0; + + while MStream.Position < MStream.Size do + begin + MStream.Read(ch, 1); + if ch = 144 then + begin + inc(NopCount); + end + else + begin + if NopCount >= 10 then + begin + if not(aEndPos) then result := MStream.Position + else result := MStream.Position - NopCount - 1; + break; + end + else NopCount := 0; + end; + end; + end; + end; + +begin + result := TMemoryStream.Create; + + if FileExists(aFileName) then + begin + MStream := TMemoryStream.Create; + try + MStream.LoadFromFile(aFileName); + + StartPos := FindPos(MStream, 0, false); + if StartPos >= 0 then + begin + if MStream.Size > StartPos + 16384 then + begin + EndPos := FindPos(MStream, MStream.Size - 16384, true); + if EndPos < 0 then EndPos := FindPos(MStream, StartPos, true); + end + else EndPos := FindPos(MStream, StartPos, true); + end; + + if (StartPos < 0) OR + (EndPos < 0) then exit; + + MStream.Position := StartPos - 1; + result.CopyFrom(MStream, EndPos - StartPos + 1); + finally + FreeAndNil(MStream); + end; + end; +end; + +end. diff --git a/tests/utils/avx/options.pas b/tests/utils/avx/options.pas new file mode 100644 index 0000000000..9d75b8c047 --- /dev/null +++ b/tests/utils/avx/options.pas @@ -0,0 +1,116 @@ +{ + + Copyright (C) <avx-testfile-generator> <Torsten Grundke> + + This source is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 2 of the License, or (at your option) + any later version. + + This code 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. + + A copy of the GNU General Public License is available on the World Wide Web + at <http://www.gnu.org/copyleft/gpl.html>. You can also obtain it by writing + to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. +} + +{$mode objfpc} + +unit options; + +interface + +type + + TOptions = class(TObject) + private + FHelp: boolean; + FX64: boolean; + FOutputFormat: Char; + FPath: string; + public + constructor Create; + + procedure LoadParams; + + property Help: boolean read FHelp write FHelp; + property OutputFormat: Char read FOutputFormat write FOutputFormat; + property X64: boolean read FX64 write FX64; + property Path: string read FPath write FPath; + end; + +implementation + +uses SysUtils; + +{ TOptions } + +constructor TOptions.Create; +begin + FHelp := false; + FX64 := false; + FOutputFormat := '?'; + FPath := ''; +end; + +procedure TOptions.LoadParams; +var + i: integer; + sParam: Char; + sValue: String; + IsInvalidParam: boolean; +begin + if ParamCount = 0 then FHelp := true + else FHelp := false; + + FX64 := false; + FOutputFormat := 'f'; // default = fpc + FPath := IncludeTrailingBackslash(GetCurrentDir); + + for i := 1 to ParamCount do + begin + if copy(ParamStr(i), 1, 1) = '-' then + begin + sParam := copy(ParamStr(i) + ' ', 2, 1)[1]; + sValue := copy(ParamStr(i), 3, length(ParamStr(i))); + + IsInvalidParam := false; + case sParam of + 'h': FHelp := true; + 'f': if sValue = 'fpc' then FOutputFormat := 'f' + else if sValue = 'nasm' then FOutputFormat := 'n' + else IsInvalidParam := true; + 'p': if sValue = 'x8664' then + begin + Fx64 := true; + end + else IsInvalidParam := true; + 'o': if sValue <> '' then + begin + FPath := IncludeTrailingBackslash(sValue); + end + else + begin + FPath := ''; + end; + else begin + FHelp := true; + writeln(format('invalid param "%s"', [ParamStr(i)])); + end; + end; + end + else IsInvalidParam := true; + + if IsInvalidParam then + begin + FHelp := true; + writeln(format('invalid param "%s"', [ParamStr(i)])); + end; + end; +end; + +end. diff --git a/tests/utils/avx/readme.txt b/tests/utils/avx/readme.txt new file mode 100644 index 0000000000..a403a53a09 --- /dev/null +++ b/tests/utils/avx/readme.txt @@ -0,0 +1,37 @@ +create testfiles in shell (linux): + +for i in `ls /tmp/avx/*.pp`; do /home/torsten/fpc/avx/ppcx64 -Fu/home/torsten/fpc/avx/rtl/units/x86_64-linux/ "$i"; done; + + +compare binary-files: + +any instructions can have a different binary-streams + +e.g. + VMOVAPD XMM0, XMM1: + + possible binary-codes: + VMOVAPD xmm1, xmm2/m128 [VEX.128.66.0F.28 /r] + VMOVAPD xmm2/m128, xmm1 [VEX.128.66.0F.29 /r] + + + VMOVSD XMM1, XMM2, XMM3 + + possible binary-codes: + VMOVSD xmm1, xmm2, xmm3 [VEX.NDS.LIG.F2.0F.WIG.10 /r] operand encoding: RVM + VMOVSD xmm1, xmm2, xmm3 [VEX.NDS.LIG.F2.0F.WIG.11 /r] operand encoding: MVR + + +currently (AVX I): + +VMOVAPD +VMOVAPS +VMOVDQA +VMOVDQU +VMOVQ +VMOVSD +VMOVSS +VMOVUPD +VMOVUPS + + |