← Back to branch summary

~bkerensa/ubuntu/raring/valgrind/merge-from-deb

« back to all changes in this revision

Viewing changes to memcheck/tests/x86/sse_memory.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-06-26 00:17:17 UTC
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: james.westby@ubuntu.com-20060626001717-qi51nzty57cb12q6
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
memcheck/tests/x86/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 <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 = memalign(16,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