Home | History | Annotate | Download | only in amd64 
      1 
      2 /* A program to test that SSE/SSE2 insns do not read memory they
      3    should not.  Covers insns of the form OP %xmm, %xmm and OP memory,
      4    %xmm only. */
      5 
      6 #include <stdio.h>
      7 #include <stdlib.h>
      8 #include <assert.h>
      9 #include "tests/malloc.h"
     10 #include <string.h>
     11 
     12 typedef  unsigned char  V128[16];
     13 typedef  unsigned int   UInt;
     14 typedef  signed int     Int;
     15 typedef  unsigned char  UChar;
     16 
     17 typedef
     18    struct {
     19       V128 arg1;
     20       V128 arg2;
     21       V128 res;
     22    }
     23    RRArgs;
     24 
     25 typedef
     26    struct {
     27       V128 arg1;
     28       V128 res;
     29    }
     30    RMArgs;
     31 
     32 static UChar randUChar ( void )
     33 {
     34    static UInt seed = 80021;
     35    seed = 1103515245 * seed + 12345;
     36    return (seed >> 17) & 0xFF;
     37 }
     38 
     39 static void randomise ( UChar* p, Int n )
     40 {
     41    Int i;
     42    for (i = 0; i < n; i++)
     43       p[i] = randUChar();
     44 }
     45 
     46 static void randV128 ( V128* v )
     47 {
     48    Int i;
     49    for (i = 0; i < 16; i++)
     50       (*v)[i] = randUChar();
     51 }
     52 
     53 static void randRRArgs ( RRArgs* rra )
     54 {
     55    randV128(&rra->arg1);
     56    randV128(&rra->arg2);
     57    randV128(&rra->res);
     58 }
     59 
     60 static void randRMArgs ( RMArgs* rra )
     61 {
     62    randV128(&rra->arg1);
     63    randV128(&rra->res);
     64 }
     65 
     66 static void showV128 ( V128* v )
     67 {
     68    Int i;
     69    for (i = 0; i < 16; i++)
     70       printf("%02x", (Int)(*v)[i]);
     71 }
     72 
     73 static void showMaskedV128 ( V128* v, V128* mask )
     74 {
     75    Int i;
     76    for (i = 0; i < 16; i++)
     77       printf("%02x", (Int)( ((*v)[i]) & ((*mask)[i]) ));
     78 }
     79 
     80 static void showRR ( char* op, RRArgs* rra, V128* rmask )
     81 {
     82    printf("r %10s ", op);
     83    showV128(&rra->arg1);
     84    printf(" ");
     85    showV128(&rra->arg2);
     86    printf(" ");
     87    showMaskedV128(&rra->res, rmask);
     88    printf("\n");
     89 }
     90 
     91 static void showRM ( char* op, RMArgs* rra, UChar* mem, Int nMem, V128* rmask )
     92 {
     93    Int i;
     94    assert(nMem == 4 || nMem == 8 || nMem == 16 || nMem==0);
     95    printf("m %10s ", op);
     96    for (i = 0; i < nMem; i++)
     97       printf("%02x", (Int)mem[i]);
     98    printf(" ");
     99    showV128(&rra->arg1);
    100    printf(" ");
    101    showMaskedV128(&rra->res, rmask );
    102    printf("\n");
    103 }
    104 
    105 #define Wrapper_RegReg(OP)                 \
    106    void r_r_##OP ( RRArgs* p )             \
    107    {                                       \
    108       __asm__ __volatile__("\n"            \
    109          "\tmovups 0(%0), %%xmm6\n"        \
    110          "\tmovups 16(%0), %%xmm7\n"       \
    111          "\t" #OP " %%xmm6, %%xmm7\n"      \
    112          "\tmovups %%xmm7, 32(%0)\n"       \
    113          :                                 \
    114          : "r" (p)                         \
    115          : "memory", "xmm6", "xmm7", "cc"  \
    116       );                                   \
    117    }
    118 
    119 #define Wrapper_RegMem(OP)                 \
    120    void r_m_##OP ( RMArgs* p, void* mem )  \
    121    {                                       \
    122       __asm__ __volatile__("\n"            \
    123          "\tmovups 0(%0), %%xmm7\n"        \
    124          "\t" #OP " 0(%1), %%xmm7\n"       \
    125          "\tmovups %%xmm7, 16(%0)\n"       \
    126          :                                 \
    127          : "r" (p), "r" (mem)              \
    128          : "memory", "xmm7", "cc"          \
    129       );                                   \
    130    }
    131 
    132 
    133 #define TEST_INSN(res_mask,mem_size,insn)  \
    134                                            \
    135 Wrapper_RegReg(insn)                       \
    136 Wrapper_RegMem(insn)                       \
    137                                            \
    138 void do_##insn ( void )                    \
    139 {                                          \
    140    Int    i;                               \
    141    UChar* buf;                             \
    142    RRArgs rargs __attribute__((aligned(16))); \
    143    RMArgs margs __attribute__((aligned(16))); \
    144    for (i = 0; i < 5; i++) {               \
    145       randRRArgs(&rargs);                  \
    146       r_r_##insn(&rargs);                  \
    147       showRR(#insn, &rargs, res_mask);     \
    148    }                                       \
    149    for (i = 0; i < 5; i++) {               \
    150       randRMArgs(&margs);                  \
    151       buf = memalign16(mem_size);          \
    152       randomise(buf,mem_size);             \
    153       r_m_##insn(&margs,buf);              \
    154       showRM(#insn, &margs, buf, mem_size, res_mask);\
    155       free(buf);                           \
    156    }                                       \
    157 }
    158 
    159 /* Note: these are little endian.  Hence first byte is the least
    160    significant byte of lane zero. */
    161 
    162 /* Mask for insns where all result bits are non-approximated. */
    163 static V128 AllMask  = { 0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,
    164                          0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF };
    165 
    166 /* Mark for insns which produce approximated vector short results. */
    167 static V128 ApproxPS = { 0x00,0x00,0x80,0xFF, 0x00,0x00,0x80,0xFF,
    168                          0x00,0x00,0x80,0xFF, 0x00,0x00,0x80,0xFF };
    169 
    170 /* Mark for insns which produce approximated scalar short results. */
    171 static V128 ApproxSS = { 0x00,0x00,0x80,0xFF, 0xFF,0xFF,0xFF,0xFF,
    172                          0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF };
    173 
    174 #define PD 16
    175 #define SD 8
    176 #define PS 16
    177 #define SS 4
    178 
    179 /* ------------------------ SSE1 ------------------------ */
    180 TEST_INSN( &AllMask, PS,addps)
    181 TEST_INSN( &AllMask, SS,addss)
    182 TEST_INSN( &AllMask, PS,andnps)
    183 TEST_INSN( &AllMask, PS,andps)
    184 TEST_INSN( &AllMask, PS,cmpeqps)
    185 TEST_INSN( &AllMask, SS,cmpeqss)
    186 TEST_INSN( &AllMask, PS,cmpleps)
    187 TEST_INSN( &AllMask, SS,cmpless)
    188 TEST_INSN( &AllMask, PS,cmpltps)
    189 TEST_INSN( &AllMask, SS,cmpltss)
    190 TEST_INSN( &AllMask, PS,cmpneqps)
    191 TEST_INSN( &AllMask, SS,cmpneqss)
    192 TEST_INSN( &AllMask, PS,cmpnleps)
    193 TEST_INSN( &AllMask, SS,cmpnless)
    194 TEST_INSN( &AllMask, PS,cmpnltps)
    195 TEST_INSN( &AllMask, SS,cmpnltss)
    196 TEST_INSN( &AllMask, PS,cmpordps)
    197 TEST_INSN( &AllMask, SS,cmpordss)
    198 TEST_INSN( &AllMask, PS,cmpunordps)
    199 TEST_INSN( &AllMask, SS,cmpunordss)
    200 TEST_INSN( &AllMask, SS,comiss)
    201 //TEST_INSN( &AllMask, 0,cvtpi2ps)
    202 //TEST_INSN( &AllMask, 0,cvtps2pi)
    203 //TEST_INSN( &AllMask, 0,cvtsi2ss)
    204 //TEST_INSN( &AllMask, 0,cvtss2si)
    205 //TEST_INSN( &AllMask, 0,cvttps2pi)
    206 //TEST_INSN( &AllMask, 0,cvttss2si)
    207 TEST_INSN( &AllMask, PS,divps)
    208 TEST_INSN( &AllMask, SS,divss)
    209 TEST_INSN( &AllMask, PS,maxps)
    210 TEST_INSN( &AllMask, SS,maxss)
    211 TEST_INSN( &AllMask, PS,minps)
    212 TEST_INSN( &AllMask, SS,minss)
    213 TEST_INSN( &AllMask, 16,movaps)
    214 //TEST_INSN( &AllMask, 0,movhlps)
    215 //TEST_INSN( &AllMask, 0,movhps)
    216 //TEST_INSN( &AllMask, 0,movlhps)
    217 //TEST_INSN( &AllMask, 0,movlps)
    218 //TEST_INSN( &AllMask, 0,movmskps)
    219 //TEST_INSN( &AllMask, 0,movntps)
    220 //TEST_INSN( &AllMask, 0,movntq)
    221 TEST_INSN( &AllMask, 4,movss)
    222 TEST_INSN( &AllMask, 16,movups)
    223 TEST_INSN( &AllMask, PS,mulps)
    224 TEST_INSN( &AllMask, SS,mulss)
    225 TEST_INSN( &AllMask, PS,orps)
    226 //TEST_INSN( &AllMask, 0,pavgb) -- dup with sse2?
    227 //TEST_INSN( &AllMask, 0,pavgw) -- dup with sse2?
    228 //TEST_INSN( &AllMask, 0,pextrw)
    229 //TEST_INSN( &AllMask, 0,pinsrw)
    230 //TEST_INSN( &AllMask, 0,pmaxsw) -- dup with sse2?
    231 //TEST_INSN( &AllMask, 0,pmaxub) -- dup with sse2?
    232 //TEST_INSN( &AllMask, 0,pminsw) -- dup with sse2?
    233 //TEST_INSN( &AllMask, 0,pminub) -- dup with sse2?
    234 //TEST_INSN( &AllMask, 0,pmovmskb)
    235 //TEST_INSN( &AllMask, 0,pmulhuw) -- dup with sse2?
    236 TEST_INSN( &AllMask, 16,psadbw) // -- XXXXXXXXXXXXXXXX sse2 (xmm variant) not implemented!
    237 //TEST_INSN( &AllMask, 0,pshufw)
    238 TEST_INSN(&ApproxPS, PS,rcpps)
    239 TEST_INSN(&ApproxSS, SS,rcpss)
    240 TEST_INSN(&ApproxPS, PS,rsqrtps)
    241 TEST_INSN(&ApproxSS, SS,rsqrtss)
    242 //TEST_INSN( &AllMask, PS,shufps)
    243 TEST_INSN( &AllMask, PS,sqrtps)
    244 TEST_INSN( &AllMask, SS,sqrtss)
    245 TEST_INSN( &AllMask, PS,subps)
    246 TEST_INSN( &AllMask, SS,subss)
    247 TEST_INSN( &AllMask, SS,ucomiss)
    248 TEST_INSN( &AllMask, PS,unpckhps)
    249 TEST_INSN( &AllMask, PS,unpcklps)
    250 TEST_INSN( &AllMask, PS,xorps)
    251 
    252 
    253 /* ------------------------ SSE2 ------------------------ */
    254 TEST_INSN( &AllMask, PD,addpd)
    255 TEST_INSN( &AllMask, SD,addsd)
    256 TEST_INSN( &AllMask, PD,andnpd)
    257 TEST_INSN( &AllMask, PD,andpd)
    258 TEST_INSN( &AllMask, PD,cmpeqpd)
    259 TEST_INSN( &AllMask, SD,cmpeqsd)
    260 TEST_INSN( &AllMask, PD,cmplepd)
    261 TEST_INSN( &AllMask, SD,cmplesd)
    262 TEST_INSN( &AllMask, PD,cmpltpd)
    263 TEST_INSN( &AllMask, SD,cmpltsd)
    264 TEST_INSN( &AllMask, PD,cmpneqpd)
    265 TEST_INSN( &AllMask, SD,cmpneqsd)
    266 TEST_INSN( &AllMask, PD,cmpnlepd)
    267 TEST_INSN( &AllMask, SD,cmpnlesd)
    268 TEST_INSN( &AllMask, PD,cmpnltpd)
    269 TEST_INSN( &AllMask, SD,cmpnltsd)
    270 TEST_INSN( &AllMask, PD,cmpordpd)
    271 TEST_INSN( &AllMask, SD,cmpordsd)
    272 TEST_INSN( &AllMask, PD,cmpunordpd)
    273 TEST_INSN( &AllMask, SD,cmpunordsd)
    274 TEST_INSN( &AllMask, SD,comisd)
    275 TEST_INSN( &AllMask, 8,cvtdq2pd)
    276 TEST_INSN( &AllMask, 16,cvtdq2ps)
    277 TEST_INSN( &AllMask, 16,cvtpd2dq)
    278 //TEST_INSN( &AllMask, 0,cvtpd2pi)
    279 TEST_INSN( &AllMask, 16,cvtpd2ps)   /* reads 16 */
    280 //TEST_INSN( &AllMask, 0,cvtpi2pd)
    281 TEST_INSN( &AllMask, 16,cvtps2dq)  /* reads 16 */
    282 TEST_INSN( &AllMask, 8,cvtps2pd)   /* reads 8 */
    283 //TEST_INSN( &AllMask, 0,cvtsd2si)
    284 TEST_INSN( &AllMask, SD,cvtsd2ss)   /* reads SD */
    285 //TEST_INSN( &AllMask, 0,cvtsi2sd)
    286 TEST_INSN( &AllMask, SS,cvtss2sd)   /* reads SS */
    287 TEST_INSN( &AllMask, 16,cvttpd2dq)
    288 //TEST_INSN( &AllMask, 0,cvttpd2pi)
    289 TEST_INSN( &AllMask, 16,cvttps2dq)
    290 //TEST_INSN( &AllMask, 0,cvttsd2si)
    291 TEST_INSN( &AllMask, PD,divpd)
    292 TEST_INSN( &AllMask, SD,divsd)
    293 TEST_INSN( &AllMask, PD,maxpd)
    294 TEST_INSN( &AllMask, SD,maxsd)
    295 TEST_INSN( &AllMask, PD,minpd)
    296 TEST_INSN( &AllMask, SD,minsd)
    297 TEST_INSN( &AllMask, PD,movapd)
    298 //TEST_INSN( &AllMask, 8,movd)
    299 //TEST_INSN( &AllMask, 0,movdq2q)
    300 TEST_INSN( &AllMask, 16,movdqa)
    301 TEST_INSN( &AllMask, 16,movdqu)
    302 //TEST_INSN( &AllMask, 16,movhpd)
    303 //TEST_INSN( &AllMask, 16,movlpd)
    304 //TEST_INSN( &AllMask, 0,movmskpd)
    305 //TEST_INSN( &AllMask, 0,movntdq)
    306 //TEST_INSN( &AllMask, 0,movnti)
    307 //TEST_INSN( &AllMask, 0,movntpd)
    308 TEST_INSN( &AllMask, 8,movq)
    309 //TEST_INSN( &AllMask, 0,movq2dq)
    310 TEST_INSN( &AllMask, 8,movsd)
    311 TEST_INSN( &AllMask, 16,movupd)
    312 TEST_INSN( &AllMask, PD,mulpd)
    313 TEST_INSN( &AllMask, SD,mulsd)
    314 TEST_INSN( &AllMask, PD,orpd)
    315 TEST_INSN( &AllMask, 16,packssdw)
    316 TEST_INSN( &AllMask, 16,packsswb)
    317 TEST_INSN( &AllMask, 16,packuswb)
    318 TEST_INSN( &AllMask, 16,paddb)
    319 TEST_INSN( &AllMask, 16,paddd)
    320 TEST_INSN( &AllMask, 16,paddq)
    321 TEST_INSN( &AllMask, 16,paddsb)
    322 TEST_INSN( &AllMask, 16,paddsw)
    323 TEST_INSN( &AllMask, 16,paddusb)
    324 TEST_INSN( &AllMask, 16,paddusw)
    325 TEST_INSN( &AllMask, 16,paddw)
    326 TEST_INSN( &AllMask, 16,pand)
    327 TEST_INSN( &AllMask, 16,pandn)
    328 TEST_INSN( &AllMask, 16,pavgb)
    329 TEST_INSN( &AllMask, 16,pavgw)
    330 TEST_INSN( &AllMask, 16,pcmpeqb)
    331 TEST_INSN( &AllMask, 16,pcmpeqd)
    332 TEST_INSN( &AllMask, 16,pcmpeqw)
    333 TEST_INSN( &AllMask, 16,pcmpgtb)
    334 TEST_INSN( &AllMask, 16,pcmpgtd)
    335 TEST_INSN( &AllMask, 16,pcmpgtw)
    336 //TEST_INSN( &AllMask, 16,pextrw)
    337 //TEST_INSN( &AllMask, 16,pinsrw)
    338 TEST_INSN( &AllMask, 16,pmaxsw)
    339 TEST_INSN( &AllMask, 16,pmaxub)
    340 TEST_INSN( &AllMask, 16,pminsw)
    341 TEST_INSN( &AllMask, 16,pminub)
    342 //TEST_INSN( &AllMask, 0,pmovmskb)
    343 TEST_INSN( &AllMask, 16,pmulhuw)
    344 TEST_INSN( &AllMask, 16,pmulhw)
    345 TEST_INSN( &AllMask, 16,pmullw)
    346 TEST_INSN( &AllMask, 16,pmuludq)
    347 TEST_INSN( &AllMask, 16,por)
    348 //TEST_INSN( &AllMask, 16,pshufd)
    349 //TEST_INSN( &AllMask, 16,pshufhw)
    350 //TEST_INSN( &AllMask, 16,pshuflw)
    351 TEST_INSN( &AllMask, 16,pslld)
    352 //TEST_INSN( &AllMask, 16,pslldq)
    353 TEST_INSN( &AllMask, 16,psllq)
    354 TEST_INSN( &AllMask, 16,psllw)
    355 TEST_INSN( &AllMask, 16,psrad)
    356 TEST_INSN( &AllMask, 16,psraw)
    357 TEST_INSN( &AllMask, 16,psrld)
    358 //TEST_INSN( &AllMask, 16,psrldq)
    359 TEST_INSN( &AllMask, 16,psrlq)
    360 TEST_INSN( &AllMask, 16,psrlw)
    361 TEST_INSN( &AllMask, 16,psubb)
    362 TEST_INSN( &AllMask, 16,psubd)
    363 TEST_INSN( &AllMask, 16,psubq)
    364 TEST_INSN( &AllMask, 16,psubsb)
    365 TEST_INSN( &AllMask, 16,psubsw)
    366 TEST_INSN( &AllMask, 16,psubusb)
    367 TEST_INSN( &AllMask, 16,psubusw)
    368 TEST_INSN( &AllMask, 16,psubw)
    369 TEST_INSN( &AllMask, 16,punpckhbw)
    370 TEST_INSN( &AllMask, 16,punpckhdq)
    371 TEST_INSN( &AllMask, 16,punpckhqdq)
    372 TEST_INSN( &AllMask, 16,punpckhwd)
    373 TEST_INSN( &AllMask, 16,punpcklbw)
    374 TEST_INSN( &AllMask, 16,punpckldq)
    375 TEST_INSN( &AllMask, 16,punpcklqdq)
    376 TEST_INSN( &AllMask, 16,punpcklwd)
    377 TEST_INSN( &AllMask, 16,pxor)
    378 //TEST_INSN( &AllMask, PD,shufpd)
    379 TEST_INSN( &AllMask, PD,sqrtpd)
    380 TEST_INSN( &AllMask, SD,sqrtsd)
    381 TEST_INSN( &AllMask, PD,subpd)
    382 TEST_INSN( &AllMask, SD,subsd)
    383 TEST_INSN( &AllMask, SD,ucomisd)
    384 TEST_INSN( &AllMask, PD,unpckhpd)
    385 TEST_INSN( &AllMask, PD,unpcklpd)
    386 TEST_INSN( &AllMask, PD,xorpd)
    387 
    388 
    389 int main ( int argc, char** argv )
    390 {
    391    Int sse1 = 0, sse2 = 0;
    392 
    393    if (argc == 2 && 0==strcmp(argv[1], "sse1")) {
    394       sse1 = 1;
    395    }
    396    else
    397    if (argc == 2 && 0==strcmp(argv[1], "sse2")) {
    398       sse2 = 1;
    399    }
    400    else
    401    if (argc == 2 && 0==strcmp(argv[1], "all")) {
    402       sse1 = sse2 = 1;
    403    }
    404    else {
    405       fprintf(stderr, "usage: sse_memory [sse1|sse2|all]\n");
    406       return 0;
    407    }
    408 
    409    /* ------------------------ SSE1 ------------------------ */
    410    if (sse1) {
    411       do_addps();
    412       do_addss();
    413       do_andnps();
    414       do_andps();
    415       do_cmpeqps();
    416       do_cmpeqss();
    417       do_cmpleps();
    418       do_cmpless();
    419       do_cmpltps();
    420       do_cmpltss();
    421       do_cmpneqps();
    422       do_cmpneqss();
    423       do_cmpnleps();
    424       do_cmpnless();
    425       do_cmpnltps();
    426       do_cmpnltss();
    427       do_cmpordps();
    428       do_cmpordss();
    429       do_cmpunordps();
    430       do_cmpunordss();
    431       do_comiss();
    432       //TEST_INSN( &AllMask, 0,cvtpi2ps)
    433       //TEST_INSN( &AllMask, 0,cvtps2pi)
    434       //TEST_INSN( &AllMask, 0,cvtsi2ss)
    435       //TEST_INSN( &AllMask, 0,cvtss2si)
    436       //TEST_INSN( &AllMask, 0,cvttps2pi)
    437       //TEST_INSN( &AllMask, 0,cvttss2si)
    438       do_divps();
    439       do_divss();
    440       do_maxps();
    441       do_maxss();
    442       do_minps();
    443       do_minss();
    444       do_movaps();
    445       //TEST_INSN( &AllMask, 0,movhlps)
    446       //TEST_INSN( &AllMask, 0,movhps)
    447       //TEST_INSN( &AllMask, 0,movlhps)
    448       //TEST_INSN( &AllMask, 0,movlps)
    449       //TEST_INSN( &AllMask, 0,movmskps)
    450       //TEST_INSN( &AllMask, 0,movntps)
    451       //TEST_INSN( &AllMask, 0,movntq)
    452       do_movss();
    453       do_movups();
    454       do_mulps();
    455       do_mulss();
    456       do_orps();
    457       //TEST_INSN( &AllMask, 0,pavgb) -- dup with sse2?
    458       //TEST_INSN( &AllMask, 0,pavgw) -- dup with sse2?
    459       //TEST_INSN( &AllMask, 0,pextrw)
    460       //TEST_INSN( &AllMask, 0,pinsrw)
    461       //TEST_INSN( &AllMask, 0,pmaxsw) -- dup with sse2?
    462       //TEST_INSN( &AllMask, 0,pmaxub) -- dup with sse2?
    463       //TEST_INSN( &AllMask, 0,pminsw) -- dup with sse2?
    464       //TEST_INSN( &AllMask, 0,pminub) -- dup with sse2?
    465       //TEST_INSN( &AllMask, 0,pmovmskb)
    466       //TEST_INSN( &AllMask, 0,pmulhuw) -- dup with sse2?
    467       //do_psadbw();  -- XXXXXXXXXXXXXXXX sse2 (xmm variant) not implemented!
    468       //TEST_INSN( &AllMask, 0,pshufw)
    469       do_rcpps();
    470       do_rcpss();
    471       do_rsqrtps();
    472       do_rsqrtss();
    473       //TEST_INSN( &AllMask, PS,shufps)
    474       do_sqrtps();
    475       do_sqrtss();
    476       do_subps();
    477       do_subss();
    478       do_ucomiss();
    479       do_unpckhps();
    480       do_unpcklps();
    481       do_xorps();
    482    }
    483 
    484    /* ------------------------ SSE2 ------------------------ */
    485    if (sse2) {
    486       do_addpd();
    487       do_addsd();
    488       do_andnpd();
    489       do_andpd();
    490       do_cmpeqpd();
    491       do_cmpeqsd();
    492       do_cmplepd();
    493       do_cmplesd();
    494       do_cmpltpd();
    495       do_cmpltsd();
    496       do_cmpneqpd();
    497       do_cmpneqsd();
    498       do_cmpnlepd();
    499       do_cmpnlesd();
    500       do_cmpnltpd();
    501       do_cmpnltsd();
    502       do_cmpordpd();
    503       do_cmpordsd();
    504       do_cmpunordpd();
    505       do_cmpunordsd();
    506       do_comisd();
    507       do_cvtdq2pd();
    508       do_cvtdq2ps();
    509       do_cvtpd2dq();
    510       //TEST_INSN( &AllMask, 0,cvtpd2pi)
    511       do_cvtpd2ps();
    512       //TEST_INSN( &AllMask, 0,cvtpi2pd)
    513       do_cvtps2dq();
    514       do_cvtps2pd();
    515       //TEST_INSN( &AllMask, 0,cvtsd2si)
    516       do_cvtsd2ss();
    517       //TEST_INSN( &AllMask, 0,cvtsi2sd)
    518       do_cvtss2sd();
    519       do_cvttpd2dq();
    520       //TEST_INSN( &AllMask, 0,cvttpd2pi)
    521       do_cvttps2dq();
    522       //TEST_INSN( &AllMask, 0,cvttsd2si)
    523       do_divpd();
    524       do_divsd();
    525       do_maxpd();
    526       do_maxsd();
    527       do_minpd();
    528       do_minsd();
    529       do_movapd();
    530       //TEST_INSN( &AllMask, 8,movd)
    531       //TEST_INSN( &AllMask, 0,movdq2q)
    532       do_movdqa();
    533       do_movdqu();
    534       //TEST_INSN( &AllMask, 16,movhpd)
    535       //TEST_INSN( &AllMask, 16,movlpd)
    536       //TEST_INSN( &AllMask, 0,movmskpd)
    537       //TEST_INSN( &AllMask, 0,movntdq)
    538       //TEST_INSN( &AllMask, 0,movnti)
    539       //TEST_INSN( &AllMask, 0,movntpd)
    540       do_movq();
    541       //TEST_INSN( &AllMask, 0,movq2dq)
    542       do_movsd();
    543       do_movupd();
    544       do_mulpd();
    545       do_mulsd();
    546       do_orpd();
    547       do_packssdw();
    548       do_packsswb();
    549       do_packuswb();
    550       do_paddb();
    551       do_paddd();
    552       do_paddq();
    553       do_paddsb();
    554       do_paddsw();
    555       do_paddusb();
    556       do_paddusw();
    557       do_paddw();
    558       do_pand();
    559       do_pandn();
    560       do_pavgb();
    561       do_pavgw();
    562       do_pcmpeqb();
    563       do_pcmpeqd();
    564       do_pcmpeqw();
    565       do_pcmpgtb();
    566       do_pcmpgtd();
    567       do_pcmpgtw();
    568       //TEST_INSN( &AllMask, 16,pextrw)
    569       //TEST_INSN( &AllMask, 16,pinsrw)
    570       do_pmaxsw();
    571       do_pmaxub();
    572       do_pminsw();
    573       do_pminub();
    574       //TEST_INSN( &AllMask, 0,pmovmskb)
    575       do_pmulhuw();
    576       do_pmulhw();
    577       do_pmullw();
    578       do_pmuludq();
    579       do_por();
    580       //TEST_INSN( &AllMask, 16,pshufd)
    581       //TEST_INSN( &AllMask, 16,pshufhw)
    582       //TEST_INSN( &AllMask, 16,pshuflw)
    583       do_pslld();
    584       //TEST_INSN( &AllMask, 16,pslldq)
    585       do_psllq();
    586       do_psllw();
    587       do_psrad();
    588       do_psraw();
    589       do_psrld();
    590       //TEST_INSN( &AllMask, 16,psrldq)
    591       do_psrlq();
    592       do_psrlw();
    593       do_psubb();
    594       do_psubd();
    595       do_psubq();
    596       do_psubsb();
    597       do_psubsw();
    598       do_psubusb();
    599       do_psubusw();
    600       do_psubw();
    601       do_punpckhbw();
    602       do_punpckhdq();
    603       do_punpckhqdq();
    604       do_punpckhwd();
    605       do_punpcklbw();
    606       do_punpckldq();
    607       do_punpcklqdq();
    608       do_punpcklwd();
    609       do_pxor();
    610       //TEST_INSN( &AllMask, PD,shufpd)
    611       do_sqrtpd();
    612       do_sqrtsd();
    613       do_subpd();
    614       do_subsd();
    615       do_ucomisd();
    616       do_unpckhpd();
    617       do_unpcklpd();
    618       do_xorpd();
    619    }
    620 
    621    return 0;
    622 }
    623 
    624