memcheck/tests/amd64/sse_memory.c

   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