* merged avx support in inline assembler developed by Torsten Grundke

git-svn-id: trunk@22568 -

.gitattributes

@@ -10409,12 +10409,20 @@ tests/test/tarrconstr2.pp svneol=native#text/pascal
 tests/test/tarrconstr3.pp svneol=native#text/pascal
 tests/test/tarrconstr4.pp svneol=native#text/pascal
 tests/test/tasm1.pp svneol=native#text/plain
+tests/test/tasm10.pp svneol=native#text/plain
+tests/test/tasm11.pp svneol=native#text/plain
+tests/test/tasm12.pp svneol=native#text/plain
+tests/test/tasm13.pp svneol=native#text/plain
+tests/test/tasm14.pp svneol=native#text/plain
+tests/test/tasm15.pp svneol=native#text/plain
 tests/test/tasm2.pp svneol=native#text/plain
 tests/test/tasm3.pp svneol=native#text/plain
 tests/test/tasm4.pp svneol=native#text/plain
 tests/test/tasm5.pp svneol=native#text/plain
 tests/test/tasm6.pp svneol=native#text/plain
 tests/test/tasm7.pp svneol=native#text/plain
+tests/test/tasm8.pp svneol=native#text/plain
+tests/test/tasm9.pp svneol=native#text/plain
 tests/test/tasmread.pp svneol=native#text/plain
 tests/test/tasout.pp svneol=native#text/plain
 tests/test/tassignmentoperator1.pp svneol=native#text/pascal
@@ -11646,6 +11654,15 @@ tests/tstunits/popuperr.pp svneol=native#text/plain
 tests/tstunits/win32err.pp svneol=native#text/plain
 tests/utils/Makefile svneol=native#text/plain
 tests/utils/Makefile.fpc svneol=native#text/plain
+tests/utils/avx/asmtestgenerator.pas svneol=native#text/plain
+tests/utils/avx/avxopcodes.pas svneol=native#text/plain
+tests/utils/avx/avxtestfilecmp.pp svneol=native#text/plain
+tests/utils/avx/avxtestgenerator.pp svneol=native#text/plain
+tests/utils/avx/baselist.pas svneol=native#text/plain
+tests/utils/avx/cmpoptions.pas svneol=native#text/plain
+tests/utils/avx/filecomparer.pas svneol=native#text/plain
+tests/utils/avx/options.pas svneol=native#text/plain
+tests/utils/avx/readme.txt svneol=native#text/plain
 tests/utils/bench.pp svneol=native#text/plain
 tests/utils/concat.pp svneol=native#text/plain
 tests/utils/dbdigest.pp svneol=native#text/plain

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',

compiler/i386/cpubase.inc

@@ -34,7 +34,8 @@
         S_MD,
         S_NEAR,S_FAR,S_SHORT,
         S_T,
-        S_XMM
+        S_XMM,
+        S_YMM
       );
 
 

compiler/i386/daopt386.pas

@@ -58,6 +58,7 @@ const
     OS_M32,
     OS_ADDR,OS_NO,OS_NO,
     OS_NO,
+    OS_NO,
     OS_NO);
 
 

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'
 );

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
 );

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'
 );

compiler/i386/i386nop.inc

@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86ins.dat }
-1208;
+1652;

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
 );

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))
 );

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
   )
 );

compiler/i386/r386ari.inc

@@ -71,4 +71,12 @@
 70,
 71,
 72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
+80,
 0

compiler/i386/r386att.inc

@@ -71,4 +71,12 @@
 '%xmm4',
 '%xmm5',
 '%xmm6',
-'%xmm7'
+'%xmm7',
+'%ymm0',
+'%ymm1',
+'%ymm2',
+'%ymm3',
+'%ymm4',
+'%ymm5',
+'%ymm6',
+'%ymm7'

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);

compiler/i386/r386dwrf.inc

@@ -71,4 +71,12 @@
 25,
 26,
 27,
+28,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
 28

compiler/i386/r386int.inc

@@ -71,4 +71,12 @@
 'xmm4',
 'xmm5',
 'xmm6',
-'xmm7'
+'xmm7',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7'

compiler/i386/r386iri.inc

@@ -71,4 +71,12 @@
 69,
 70,
 71,
-72
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
+80

compiler/i386/r386nasm.inc

@@ -71,4 +71,12 @@
 'xmm4',
 'xmm5',
 'xmm6',
-'xmm7'
+'xmm7',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7'

compiler/i386/r386nor.inc

@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86reg.dat }
-73
+81

compiler/i386/r386nri.inc

@@ -71,4 +71,12 @@
 69,
 70,
 71,
-72
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
+80

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)

compiler/i386/r386op.inc

@@ -71,4 +71,12 @@
 4,
 5,
 6,
+7,
+0,
+1,
+2,
+3,
+4,
+5,
+6,
 7

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

compiler/i386/r386rni.inc

@@ -49,6 +49,14 @@
 70,
 71,
 72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
+80,
 26,
 27,
 28,

compiler/i386/r386sri.inc

@@ -71,4 +71,12 @@
 69,
 70,
 71,
-72
+72,
+73,
+74,
+75,
+76,
+77,
+78,
+79,
+80

compiler/i386/r386stab.inc

@@ -71,4 +71,12 @@
 25,
 26,
 27,
+28,
+21,
+22,
+23,
+24,
+25,
+26,
+27,
 28

compiler/i386/r386std.inc

@@ -71,4 +71,12 @@
 'xmm4',
 'xmm5',
 'xmm6',
-'xmm7'
+'xmm7',
+'ymm0',
+'ymm1',
+'ymm2',
+'ymm3',
+'ymm4',
+'ymm5',
+'ymm6',
+'ymm7'

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;
 

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

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
   );

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'

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>

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;

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;

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]);

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;

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;
@@ -807,6 +846,9 @@ implementation
                addsize:=false;
                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'
@@ -847,6 +889,12 @@ implementation
                   else
                    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 }
@@ -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;
 
 

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

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;

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}

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;

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] = (

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;

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;

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;

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;

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

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

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
   );
 
 {*****************************************************************************

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

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'

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);

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

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'

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

compiler/x86_64/r8664nor.inc

@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86reg.dat }
-126
+142

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)

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

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

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,

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

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

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'

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
 );

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'
 );

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'
 );

compiler/x86_64/x8664nop.inc

@@ -1,2 +1,2 @@
 { don't edit, this file is generated from x86ins.dat }
-1219;
+1667;

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
 );

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))
 );

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
   )
 );

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.
+

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.

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.

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.

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.

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.

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.

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
+
+