Alex: Added the new sources for terminatorX 3.5
[terminatorX.git] / src / mmx.h
1 /*      mmx.h
2
3         MultiMedia eXtensions GCC interface library for IA32.
4
5         To use this library, simply include this header file
6         and compile with GCC.  You MUST have inlining enabled
7         in order for mmx_ok() to work; this can be done by
8         simply using -O on the GCC command line.
9
10         Compiling with -DMMX_TRACE will cause detailed trace
11         output to be sent to stderr for each mmx operation.
12         This adds lots of code, and obviously slows execution to
13         a crawl, but can be very useful for debugging.
14
15         THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
16         EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
17         LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
18         AND FITNESS FOR ANY PARTICULAR PURPOSE.
19
20         1997-99 by H. Dietz and R. Fisher
21
22  Notes:
23         It appears that the latest gas has the pand problem fixed, therefore
24           I'll undefine BROKEN_PAND by default.
25 */
26
27 #ifndef _MMX_H
28 #define _MMX_H
29
30
31 /*      Warning:  at this writing, the version of GAS packaged
32         with most Linux distributions does not handle the
33         parallel AND operation mnemonic correctly.  If the
34         symbol BROKEN_PAND is defined, a slower alternative
35         coding will be used.  If execution of mmxtest results
36         in an illegal instruction fault, define this symbol.
37 */
38 #undef  BROKEN_PAND
39
40
41 /*      The type of an value that fits in an MMX register
42         (note that long long constant values MUST be suffixed
43          by LL and unsigned long long values by ULL, lest
44          they be truncated by the compiler)
45 */
46 typedef union {
47         long long               q;      /* Quadword (64-bit) value */
48         unsigned long long      uq;     /* Unsigned Quadword */
49         int                     d[2];   /* 2 Doubleword (32-bit) values */
50         unsigned int            ud[2];  /* 2 Unsigned Doubleword */
51         short                   w[4];   /* 4 Word (16-bit) values */
52         unsigned short          uw[4];  /* 4 Unsigned Word */
53         char                    b[8];   /* 8 Byte (8-bit) values */
54         unsigned char           ub[8];  /* 8 Unsigned Byte */
55         float                   s[2];   /* Single-precision (32-bit) value */
56 } __attribute__ ((aligned (8))) mmx_t;  /* On an 8-byte (64-bit) boundary */
57
58
59
60 /*      Function to test if multimedia instructions are supported...
61 */
62 #ifdef NEED_EXTERN
63 inline int extern
64 #else
65 inline int
66 #endif
67 mm_support(void)
68 {
69         /* Returns 1 if MMX instructions are supported,
70            3 if Cyrix MMX and Extended MMX instructions are supported
71            5 if AMD MMX and 3DNow! instructions are supported
72            0 if hardware does not support any of these
73         */
74         register int rval = 0;
75
76         __asm__ __volatile__ (
77                 /* See if CPUID instruction is supported ... */
78                 /* ... Get copies of EFLAGS into eax and ecx */
79                 "pushf\n\t"
80                 "popl %%eax\n\t"
81                 "movl %%eax, %%ecx\n\t"
82
83                 /* ... Toggle the ID bit in one copy and store */
84                 /*     to the EFLAGS reg */
85                 "xorl $0x200000, %%eax\n\t"
86                 "push %%eax\n\t"
87                 "popf\n\t"
88
89                 /* ... Get the (hopefully modified) EFLAGS */
90                 "pushf\n\t"
91                 "popl %%eax\n\t"
92
93                 /* ... Compare and test result */
94                 "xorl %%eax, %%ecx\n\t"
95                 "testl $0x200000, %%ecx\n\t"
96                 "jz NotSupported1\n\t"          /* CPUID not supported */
97
98
99                 /* Get standard CPUID information, and
100                        go to a specific vendor section */
101                 "movl $0, %%eax\n\t"
102                 "cpuid\n\t"
103
104                 /* Check for Intel */
105                 "cmpl $0x756e6547, %%ebx\n\t"
106                 "jne TryAMD\n\t"
107                 "cmpl $0x49656e69, %%edx\n\t"
108                 "jne TryAMD\n\t"
109                 "cmpl $0x6c65746e, %%ecx\n"
110                 "jne TryAMD\n\t"
111                 "jmp Intel\n\t"
112
113                 /* Check for AMD */
114                 "\nTryAMD:\n\t"
115                 "cmpl $0x68747541, %%ebx\n\t"
116                 "jne TryCyrix\n\t"
117                 "cmpl $0x69746e65, %%edx\n\t"
118                 "jne TryCyrix\n\t"
119                 "cmpl $0x444d4163, %%ecx\n"
120                 "jne TryCyrix\n\t"
121                 "jmp AMD\n\t"
122
123                 /* Check for Cyrix */
124                 "\nTryCyrix:\n\t"
125                 "cmpl $0x69727943, %%ebx\n\t"
126                 "jne NotSupported2\n\t"
127                 "cmpl $0x736e4978, %%edx\n\t"
128                 "jne NotSupported3\n\t"
129                 "cmpl $0x64616574, %%ecx\n\t"
130                 "jne NotSupported4\n\t"
131                 /* Drop through to Cyrix... */
132
133
134                 /* Cyrix Section */
135                 /* See if extended CPUID level 80000001 is supported */
136                 /* The value of CPUID/80000001 for the 6x86MX is undefined
137                    according to the Cyrix CPU Detection Guide (Preliminary
138                    Rev. 1.01 table 1), so we'll check the value of eax for
139                    CPUID/0 to see if standard CPUID level 2 is supported.
140                    According to the table, the only CPU which supports level
141                    2 is also the only one which supports extended CPUID levels.
142                 */
143                 "cmpl $0x2, %%eax\n\t"
144                 "jne MMXtest\n\t"       /* Use standard CPUID instead */
145
146                 /* Extended CPUID supported (in theory), so get extended
147                    features */
148                 "movl $0x80000001, %%eax\n\t"
149                 "cpuid\n\t"
150                 "testl $0x00800000, %%eax\n\t"  /* Test for MMX */
151                 "jz NotSupported5\n\t"          /* MMX not supported */
152                 "testl $0x01000000, %%eax\n\t"  /* Test for Ext'd MMX */
153                 "jnz EMMXSupported\n\t"
154                 "movl $1, %0:\n\n\t"            /* MMX Supported */
155                 "jmp Return\n\n"
156                 "EMMXSupported:\n\t"
157                 "movl $3, %0:\n\n\t"            /* EMMX and MMX Supported */
158                 "jmp Return\n\t"
159
160
161                 /* AMD Section */
162                 "AMD:\n\t"
163
164                 /* See if extended CPUID is supported */
165                 "movl $0x80000000, %%eax\n\t"
166                 "cpuid\n\t"
167                 "cmpl $0x80000000, %%eax\n\t"
168                 "jl MMXtest\n\t"        /* Use standard CPUID instead */
169
170                 /* Extended CPUID supported, so get extended features */
171                 "movl $0x80000001, %%eax\n\t"
172                 "cpuid\n\t"
173                 "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
174                 "jz NotSupported6\n\t"          /* MMX not supported */
175                 "testl $0x80000000, %%edx\n\t"  /* Test for 3DNow! */
176                 "jnz ThreeDNowSupported\n\t"
177                 "movl $1, %0:\n\n\t"            /* MMX Supported */
178                 "jmp Return\n\n"
179                 "ThreeDNowSupported:\n\t"
180                 "movl $5, %0:\n\n\t"            /* 3DNow! and MMX Supported */
181                 "jmp Return\n\t"
182
183
184                 /* Intel Section */
185                 "Intel:\n\t"
186
187                 /* Check for MMX */
188                 "MMXtest:\n\t"
189                 "movl $1, %%eax\n\t"
190                 "cpuid\n\t"
191                 "testl $0x00800000, %%edx\n\t"  /* Test for MMX */
192                 "jz NotSupported7\n\t"          /* MMX Not supported */
193                 "movl $1, %0:\n\n\t"            /* MMX Supported */
194                 "jmp Return\n\t"
195
196                 /* Nothing supported */
197                 "\nNotSupported1:\n\t"
198                 "#movl $101, %0:\n\n\t"
199                 "\nNotSupported2:\n\t"
200                 "#movl $102, %0:\n\n\t"
201                 "\nNotSupported3:\n\t"
202                 "#movl $103, %0:\n\n\t"
203                 "\nNotSupported4:\n\t"
204                 "#movl $104, %0:\n\n\t"
205                 "\nNotSupported5:\n\t"
206                 "#movl $105, %0:\n\n\t"
207                 "\nNotSupported6:\n\t"
208                 "#movl $106, %0:\n\n\t"
209                 "\nNotSupported7:\n\t"
210                 "#movl $107, %0:\n\n\t"
211                 "movl $0, %0:\n\n\t"
212
213                 "Return:\n\t"
214                 : "=a" (rval)
215                 : /* no input */
216                 : "eax", "ebx", "ecx", "edx"
217         );
218
219         /* Return */
220         return(rval);
221 }
222
223 /*      Function to test if mmx instructions are supported...
224 */
225 inline extern int
226 mmx_ok(void)
227 {
228         /* Returns 1 if MMX instructions are supported, 0 otherwise */
229         return ( mm_support() & 0x1 );
230 }
231
232
233 /*      Helper functions for the instruction macros that follow...
234         (note that memory-to-register, m2r, instructions are nearly
235          as efficient as register-to-register, r2r, instructions;
236          however, memory-to-memory instructions are really simulated
237          as a convenience, and are only 1/3 as efficient)
238 */
239 #ifdef  MMX_TRACE
240
241 /*      Include the stuff for printing a trace to stderr...
242 */
243
244 #include <stdio.h>
245
246 #define mmx_i2r(op, imm, reg) \
247         { \
248                 mmx_t mmx_trace; \
249                 mmx_trace.uq = (imm); \
250                 fprintf(stderr, #op "_i2r(" #imm "=0x%08x%08x, ", \
251                         mmx_trace.d[1], mmx_trace.d[0]); \
252                 __asm__ __volatile__ ("movq %%" #reg ", %0" \
253                                       : "=X" (mmx_trace) \
254                                       : /* nothing */ ); \
255                 fprintf(stderr, #reg "=0x%08x%08x) => ", \
256                         mmx_trace.d[1], mmx_trace.d[0]); \
257                 __asm__ __volatile__ (#op " %0, %%" #reg \
258                                       : /* nothing */ \
259                                       : "X" (imm)); \
260                 __asm__ __volatile__ ("movq %%" #reg ", %0" \
261                                       : "=X" (mmx_trace) \
262                                       : /* nothing */ ); \
263                 fprintf(stderr, #reg "=0x%08x%08x\n", \
264                         mmx_trace.d[1], mmx_trace.d[0]); \
265         }
266
267 #define mmx_m2r(op, mem, reg) \
268         { \
269                 mmx_t mmx_trace; \
270                 mmx_trace = (mem); \
271                 fprintf(stderr, #op "_m2r(" #mem "=0x%08x%08x, ", \
272                         mmx_trace.d[1], mmx_trace.d[0]); \
273                 __asm__ __volatile__ ("movq %%" #reg ", %0" \
274                                       : "=X" (mmx_trace) \
275                                       : /* nothing */ ); \
276                 fprintf(stderr, #reg "=0x%08x%08x) => ", \
277                         mmx_trace.d[1], mmx_trace.d[0]); \
278                 __asm__ __volatile__ (#op " %0, %%" #reg \
279                                       : /* nothing */ \
280                                       : "X" (mem)); \
281                 __asm__ __volatile__ ("movq %%" #reg ", %0" \
282                                       : "=X" (mmx_trace) \
283                                       : /* nothing */ ); \
284                 fprintf(stderr, #reg "=0x%08x%08x\n", \
285                         mmx_trace.d[1], mmx_trace.d[0]); \
286         }
287
288 #define mmx_r2m(op, reg, mem) \
289         { \
290                 mmx_t mmx_trace; \
291                 __asm__ __volatile__ ("movq %%" #reg ", %0" \
292                                       : "=X" (mmx_trace) \
293                                       : /* nothing */ ); \
294                 fprintf(stderr, #op "_r2m(" #reg "=0x%08x%08x, ", \
295                         mmx_trace.d[1], mmx_trace.d[0]); \
296                 mmx_trace = (mem); \
297                 fprintf(stderr, #mem "=0x%08x%08x) => ", \
298                         mmx_trace.d[1], mmx_trace.d[0]); \
299                 __asm__ __volatile__ (#op " %%" #reg ", %0" \
300                                       : "=X" (mem) \
301                                       : /* nothing */ ); \
302                 mmx_trace = (mem); \
303                 fprintf(stderr, #mem "=0x%08x%08x\n", \
304                         mmx_trace.d[1], mmx_trace.d[0]); \
305         }
306
307 #define mmx_r2r(op, regs, regd) \
308         { \
309                 mmx_t mmx_trace; \
310                 __asm__ __volatile__ ("movq %%" #regs ", %0" \
311                                       : "=X" (mmx_trace) \
312                                       : /* nothing */ ); \
313                 fprintf(stderr, #op "_r2r(" #regs "=0x%08x%08x, ", \
314                         mmx_trace.d[1], mmx_trace.d[0]); \
315                 __asm__ __volatile__ ("movq %%" #regd ", %0" \
316                                       : "=X" (mmx_trace) \
317                                       : /* nothing */ ); \
318                 fprintf(stderr, #regd "=0x%08x%08x) => ", \
319                         mmx_trace.d[1], mmx_trace.d[0]); \
320                 __asm__ __volatile__ (#op " %" #regs ", %" #regd); \
321                 __asm__ __volatile__ ("movq %%" #regd ", %0" \
322                                       : "=X" (mmx_trace) \
323                                       : /* nothing */ ); \
324                 fprintf(stderr, #regd "=0x%08x%08x\n", \
325                         mmx_trace.d[1], mmx_trace.d[0]); \
326         }
327
328 #define mmx_m2m(op, mems, memd) \
329         { \
330                 mmx_t mmx_trace; \
331                 mmx_trace = (mems); \
332                 fprintf(stderr, #op "_m2m(" #mems "=0x%08x%08x, ", \
333                         mmx_trace.d[1], mmx_trace.d[0]); \
334                 mmx_trace = (memd); \
335                 fprintf(stderr, #memd "=0x%08x%08x) => ", \
336                         mmx_trace.d[1], mmx_trace.d[0]); \
337                 __asm__ __volatile__ ("movq %0, %%mm0\n\t" \
338                                       #op " %1, %%mm0\n\t" \
339                                       "movq %%mm0, %0" \
340                                       : "=X" (memd) \
341                                       : "X" (mems)); \
342                 mmx_trace = (memd); \
343                 fprintf(stderr, #memd "=0x%08x%08x\n", \
344                         mmx_trace.d[1], mmx_trace.d[0]); \
345         }
346
347 #else
348
349 /*      These macros are a lot simpler without the tracing...
350 */
351
352 #define mmx_i2r(op, imm, reg) \
353         __asm__ __volatile__ (#op " %0, %%" #reg \
354                               : /* nothing */ \
355                               : "X" (imm) )
356
357 #define mmx_m2r(op, mem, reg) \
358         __asm__ __volatile__ (#op " %0, %%" #reg \
359                               : /* nothing */ \
360                               : "X" (mem))
361
362 #define mmx_r2m(op, reg, mem) \
363         __asm__ __volatile__ (#op " %%" #reg ", %0" \
364                               : "=X" (mem) \
365                               : /* nothing */ )
366
367 #define mmx_r2r(op, regs, regd) \
368         __asm__ __volatile__ (#op " %" #regs ", %" #regd)
369
370 #define mmx_m2m(op, mems, memd) \
371         __asm__ __volatile__ ("movq %0, %%mm0\n\t" \
372                               #op " %1, %%mm0\n\t" \
373                               "movq %%mm0, %0" \
374                               : "=X" (memd) \
375                               : "X" (mems))
376
377 #endif
378
379
380 /*      1x64 MOVe Quadword
381         (this is both a load and a store...
382          in fact, it is the only way to store)
383 */
384 #define movq_m2r(var, reg)      mmx_m2r(movq, var, reg)
385 #define movq_r2m(reg, var)      mmx_r2m(movq, reg, var)
386 #define movq_r2r(regs, regd)    mmx_r2r(movq, regs, regd)
387 #define movq(vars, vard) \
388         __asm__ __volatile__ ("movq %1, %%mm0\n\t" \
389                               "movq %%mm0, %0" \
390                               : "=X" (vard) \
391                               : "X" (vars))
392
393
394 /*      1x32 MOVe Doubleword
395         (like movq, this is both load and store...
396          but is most useful for moving things between
397          mmx registers and ordinary registers)
398 */
399 #define movd_m2r(var, reg)      mmx_m2r(movd, var, reg)
400 #define movd_r2m(reg, var)      mmx_r2m(movd, reg, var)
401 #define movd_r2r(regs, regd)    mmx_r2r(movd, regs, regd)
402 #define movd(vars, vard) \
403         __asm__ __volatile__ ("movd %1, %%mm0\n\t" \
404                               "movd %%mm0, %0" \
405                               : "=X" (vard) \
406                               : "X" (vars))
407
408
409 /*      2x32, 4x16, and 8x8 Parallel ADDs
410 */
411 #define paddd_m2r(var, reg)     mmx_m2r(paddd, var, reg)
412 #define paddd_r2r(regs, regd)   mmx_r2r(paddd, regs, regd)
413 #define paddd(vars, vard)       mmx_m2m(paddd, vars, vard)
414
415 #define paddw_m2r(var, reg)     mmx_m2r(paddw, var, reg)
416 #define paddw_r2r(regs, regd)   mmx_r2r(paddw, regs, regd)
417 #define paddw(vars, vard)       mmx_m2m(paddw, vars, vard)
418
419 #define paddb_m2r(var, reg)     mmx_m2r(paddb, var, reg)
420 #define paddb_r2r(regs, regd)   mmx_r2r(paddb, regs, regd)
421 #define paddb(vars, vard)       mmx_m2m(paddb, vars, vard)
422
423
424 /*      4x16 and 8x8 Parallel ADDs using Saturation arithmetic
425 */
426 #define paddsw_m2r(var, reg)    mmx_m2r(paddsw, var, reg)
427 #define paddsw_r2r(regs, regd)  mmx_r2r(paddsw, regs, regd)
428 #define paddsw(vars, vard)      mmx_m2m(paddsw, vars, vard)
429
430 #define paddsb_m2r(var, reg)    mmx_m2r(paddsb, var, reg)
431 #define paddsb_r2r(regs, regd)  mmx_r2r(paddsb, regs, regd)
432 #define paddsb(vars, vard)      mmx_m2m(paddsb, vars, vard)
433
434
435 /*      4x16 and 8x8 Parallel ADDs using Unsigned Saturation arithmetic
436 */
437 #define paddusw_m2r(var, reg)   mmx_m2r(paddusw, var, reg)
438 #define paddusw_r2r(regs, regd) mmx_r2r(paddusw, regs, regd)
439 #define paddusw(vars, vard)     mmx_m2m(paddusw, vars, vard)
440
441 #define paddusb_m2r(var, reg)   mmx_m2r(paddusb, var, reg)
442 #define paddusb_r2r(regs, regd) mmx_r2r(paddusb, regs, regd)
443 #define paddusb(vars, vard)     mmx_m2m(paddusb, vars, vard)
444
445
446 /*      2x32, 4x16, and 8x8 Parallel SUBs
447 */
448 #define psubd_m2r(var, reg)     mmx_m2r(psubd, var, reg)
449 #define psubd_r2r(regs, regd)   mmx_r2r(psubd, regs, regd)
450 #define psubd(vars, vard)       mmx_m2m(psubd, vars, vard)
451
452 #define psubw_m2r(var, reg)     mmx_m2r(psubw, var, reg)
453 #define psubw_r2r(regs, regd)   mmx_r2r(psubw, regs, regd)
454 #define psubw(vars, vard)       mmx_m2m(psubw, vars, vard)
455
456 #define psubb_m2r(var, reg)     mmx_m2r(psubb, var, reg)
457 #define psubb_r2r(regs, regd)   mmx_r2r(psubb, regs, regd)
458 #define psubb(vars, vard)       mmx_m2m(psubb, vars, vard)
459
460
461 /*      4x16 and 8x8 Parallel SUBs using Saturation arithmetic
462 */
463 #define psubsw_m2r(var, reg)    mmx_m2r(psubsw, var, reg)
464 #define psubsw_r2r(regs, regd)  mmx_r2r(psubsw, regs, regd)
465 #define psubsw(vars, vard)      mmx_m2m(psubsw, vars, vard)
466
467 #define psubsb_m2r(var, reg)    mmx_m2r(psubsb, var, reg)
468 #define psubsb_r2r(regs, regd)  mmx_r2r(psubsb, regs, regd)
469 #define psubsb(vars, vard)      mmx_m2m(psubsb, vars, vard)
470
471
472 /*      4x16 and 8x8 Parallel SUBs using Unsigned Saturation arithmetic
473 */
474 #define psubusw_m2r(var, reg)   mmx_m2r(psubusw, var, reg)
475 #define psubusw_r2r(regs, regd) mmx_r2r(psubusw, regs, regd)
476 #define psubusw(vars, vard)     mmx_m2m(psubusw, vars, vard)
477
478 #define psubusb_m2r(var, reg)   mmx_m2r(psubusb, var, reg)
479 #define psubusb_r2r(regs, regd) mmx_r2r(psubusb, regs, regd)
480 #define psubusb(vars, vard)     mmx_m2m(psubusb, vars, vard)
481
482
483 /*      4x16 Parallel MULs giving Low 4x16 portions of results
484 */
485 #define pmullw_m2r(var, reg)    mmx_m2r(pmullw, var, reg)
486 #define pmullw_r2r(regs, regd)  mmx_r2r(pmullw, regs, regd)
487 #define pmullw(vars, vard)      mmx_m2m(pmullw, vars, vard)
488
489
490 /*      4x16 Parallel MULs giving High 4x16 portions of results
491 */
492 #define pmulhw_m2r(var, reg)    mmx_m2r(pmulhw, var, reg)
493 #define pmulhw_r2r(regs, regd)  mmx_r2r(pmulhw, regs, regd)
494 #define pmulhw(vars, vard)      mmx_m2m(pmulhw, vars, vard)
495
496
497 /*      4x16->2x32 Parallel Mul-ADD
498         (muls like pmullw, then adds adjacent 16-bit fields
499          in the multiply result to make the final 2x32 result)
500 */
501 #define pmaddwd_m2r(var, reg)   mmx_m2r(pmaddwd, var, reg)
502 #define pmaddwd_r2r(regs, regd) mmx_r2r(pmaddwd, regs, regd)
503 #define pmaddwd(vars, vard)     mmx_m2m(pmaddwd, vars, vard)
504
505
506 /*      1x64 bitwise AND
507 */
508 #ifdef  BROKEN_PAND
509 #define pand_m2r(var, reg) \
510         { \
511                 mmx_m2r(pandn, (mmx_t) -1LL, reg); \
512                 mmx_m2r(pandn, var, reg); \
513         }
514 #define pand_r2r(regs, regd) \
515         { \
516                 mmx_m2r(pandn, (mmx_t) -1LL, regd); \
517                 mmx_r2r(pandn, regs, regd) \
518         }
519 #define pand(vars, vard) \
520         { \
521                 movq_m2r(vard, mm0); \
522                 mmx_m2r(pandn, (mmx_t) -1LL, mm0); \
523                 mmx_m2r(pandn, vars, mm0); \
524                 movq_r2m(mm0, vard); \
525         }
526 #else
527 #define pand_m2r(var, reg)      mmx_m2r(pand, var, reg)
528 #define pand_r2r(regs, regd)    mmx_r2r(pand, regs, regd)
529 #define pand(vars, vard)        mmx_m2m(pand, vars, vard)
530 #endif
531
532
533 /*      1x64 bitwise AND with Not the destination
534 */
535 #define pandn_m2r(var, reg)     mmx_m2r(pandn, var, reg)
536 #define pandn_r2r(regs, regd)   mmx_r2r(pandn, regs, regd)
537 #define pandn(vars, vard)       mmx_m2m(pandn, vars, vard)
538
539
540 /*      1x64 bitwise OR
541 */
542 #define por_m2r(var, reg)       mmx_m2r(por, var, reg)
543 #define por_r2r(regs, regd)     mmx_r2r(por, regs, regd)
544 #define por(vars, vard) mmx_m2m(por, vars, vard)
545
546
547 /*      1x64 bitwise eXclusive OR
548 */
549 #define pxor_m2r(var, reg)      mmx_m2r(pxor, var, reg)
550 #define pxor_r2r(regs, regd)    mmx_r2r(pxor, regs, regd)
551 #define pxor(vars, vard)        mmx_m2m(pxor, vars, vard)
552
553
554 /*      2x32, 4x16, and 8x8 Parallel CoMPare for EQuality
555         (resulting fields are either 0 or -1)
556 */
557 #define pcmpeqd_m2r(var, reg)   mmx_m2r(pcmpeqd, var, reg)
558 #define pcmpeqd_r2r(regs, regd) mmx_r2r(pcmpeqd, regs, regd)
559 #define pcmpeqd(vars, vard)     mmx_m2m(pcmpeqd, vars, vard)
560
561 #define pcmpeqw_m2r(var, reg)   mmx_m2r(pcmpeqw, var, reg)
562 #define pcmpeqw_r2r(regs, regd) mmx_r2r(pcmpeqw, regs, regd)
563 #define pcmpeqw(vars, vard)     mmx_m2m(pcmpeqw, vars, vard)
564
565 #define pcmpeqb_m2r(var, reg)   mmx_m2r(pcmpeqb, var, reg)
566 #define pcmpeqb_r2r(regs, regd) mmx_r2r(pcmpeqb, regs, regd)
567 #define pcmpeqb(vars, vard)     mmx_m2m(pcmpeqb, vars, vard)
568
569
570 /*      2x32, 4x16, and 8x8 Parallel CoMPare for Greater Than
571         (resulting fields are either 0 or -1)
572 */
573 #define pcmpgtd_m2r(var, reg)   mmx_m2r(pcmpgtd, var, reg)
574 #define pcmpgtd_r2r(regs, regd) mmx_r2r(pcmpgtd, regs, regd)
575 #define pcmpgtd(vars, vard)     mmx_m2m(pcmpgtd, vars, vard)
576
577 #define pcmpgtw_m2r(var, reg)   mmx_m2r(pcmpgtw, var, reg)
578 #define pcmpgtw_r2r(regs, regd) mmx_r2r(pcmpgtw, regs, regd)
579 #define pcmpgtw(vars, vard)     mmx_m2m(pcmpgtw, vars, vard)
580
581 #define pcmpgtb_m2r(var, reg)   mmx_m2r(pcmpgtb, var, reg)
582 #define pcmpgtb_r2r(regs, regd) mmx_r2r(pcmpgtb, regs, regd)
583 #define pcmpgtb(vars, vard)     mmx_m2m(pcmpgtb, vars, vard)
584
585
586 /*      1x64, 2x32, and 4x16 Parallel Shift Left Logical
587 */
588 #define psllq_i2r(imm, reg)     mmx_i2r(psllq, imm, reg)
589 #define psllq_m2r(var, reg)     mmx_m2r(psllq, var, reg)
590 #define psllq_r2r(regs, regd)   mmx_r2r(psllq, regs, regd)
591 #define psllq(vars, vard)       mmx_m2m(psllq, vars, vard)
592
593 #define pslld_i2r(imm, reg)     mmx_i2r(pslld, imm, reg)
594 #define pslld_m2r(var, reg)     mmx_m2r(pslld, var, reg)
595 #define pslld_r2r(regs, regd)   mmx_r2r(pslld, regs, regd)
596 #define pslld(vars, vard)       mmx_m2m(pslld, vars, vard)
597
598 #define psllw_i2r(imm, reg)     mmx_i2r(psllw, imm, reg)
599 #define psllw_m2r(var, reg)     mmx_m2r(psllw, var, reg)
600 #define psllw_r2r(regs, regd)   mmx_r2r(psllw, regs, regd)
601 #define psllw(vars, vard)       mmx_m2m(psllw, vars, vard)
602
603
604 /*      1x64, 2x32, and 4x16 Parallel Shift Right Logical
605 */
606 #define psrlq_i2r(imm, reg)     mmx_i2r(psrlq, imm, reg)
607 #define psrlq_m2r(var, reg)     mmx_m2r(psrlq, var, reg)
608 #define psrlq_r2r(regs, regd)   mmx_r2r(psrlq, regs, regd)
609 #define psrlq(vars, vard)       mmx_m2m(psrlq, vars, vard)
610
611 #define psrld_i2r(imm, reg)     mmx_i2r(psrld, imm, reg)
612 #define psrld_m2r(var, reg)     mmx_m2r(psrld, var, reg)
613 #define psrld_r2r(regs, regd)   mmx_r2r(psrld, regs, regd)
614 #define psrld(vars, vard)       mmx_m2m(psrld, vars, vard)
615
616 #define psrlw_i2r(imm, reg)     mmx_i2r(psrlw, imm, reg)
617 #define psrlw_m2r(var, reg)     mmx_m2r(psrlw, var, reg)
618 #define psrlw_r2r(regs, regd)   mmx_r2r(psrlw, regs, regd)
619 #define psrlw(vars, vard)       mmx_m2m(psrlw, vars, vard)
620
621
622 /*      2x32 and 4x16 Parallel Shift Right Arithmetic
623 */
624 #define psrad_i2r(imm, reg)     mmx_i2r(psrad, imm, reg)
625 #define psrad_m2r(var, reg)     mmx_m2r(psrad, var, reg)
626 #define psrad_r2r(regs, regd)   mmx_r2r(psrad, regs, regd)
627 #define psrad(vars, vard)       mmx_m2m(psrad, vars, vard)
628
629 #define psraw_i2r(imm, reg)     mmx_i2r(psraw, imm, reg)
630 #define psraw_m2r(var, reg)     mmx_m2r(psraw, var, reg)
631 #define psraw_r2r(regs, regd)   mmx_r2r(psraw, regs, regd)
632 #define psraw(vars, vard)       mmx_m2m(psraw, vars, vard)
633
634
635 /*      2x32->4x16 and 4x16->8x8 PACK and Signed Saturate
636         (packs source and dest fields into dest in that order)
637 */
638 #define packssdw_m2r(var, reg)  mmx_m2r(packssdw, var, reg)
639 #define packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
640 #define packssdw(vars, vard)    mmx_m2m(packssdw, vars, vard)
641
642 #define packsswb_m2r(var, reg)  mmx_m2r(packsswb, var, reg)
643 #define packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
644 #define packsswb(vars, vard)    mmx_m2m(packsswb, vars, vard)
645
646
647 /*      4x16->8x8 PACK and Unsigned Saturate
648         (packs source and dest fields into dest in that order)
649 */
650 #define packuswb_m2r(var, reg)  mmx_m2r(packuswb, var, reg)
651 #define packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
652 #define packuswb(vars, vard)    mmx_m2m(packuswb, vars, vard)
653
654
655 /*      2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK Low
656         (interleaves low half of dest with low half of source
657          as padding in each result field)
658 */
659 #define punpckldq_m2r(var, reg) mmx_m2r(punpckldq, var, reg)
660 #define punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
661 #define punpckldq(vars, vard)   mmx_m2m(punpckldq, vars, vard)
662
663 #define punpcklwd_m2r(var, reg) mmx_m2r(punpcklwd, var, reg)
664 #define punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
665 #define punpcklwd(vars, vard)   mmx_m2m(punpcklwd, vars, vard)
666
667 #define punpcklbw_m2r(var, reg) mmx_m2r(punpcklbw, var, reg)
668 #define punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
669 #define punpcklbw(vars, vard)   mmx_m2m(punpcklbw, vars, vard)
670
671
672 /*      2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK High
673         (interleaves high half of dest with high half of source
674          as padding in each result field)
675 */
676 #define punpckhdq_m2r(var, reg) mmx_m2r(punpckhdq, var, reg)
677 #define punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
678 #define punpckhdq(vars, vard)   mmx_m2m(punpckhdq, vars, vard)
679
680 #define punpckhwd_m2r(var, reg) mmx_m2r(punpckhwd, var, reg)
681 #define punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
682 #define punpckhwd(vars, vard)   mmx_m2m(punpckhwd, vars, vard)
683
684 #define punpckhbw_m2r(var, reg) mmx_m2r(punpckhbw, var, reg)
685 #define punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
686 #define punpckhbw(vars, vard)   mmx_m2m(punpckhbw, vars, vard)
687
688
689 /*      Empty MMx State
690         (used to clean-up when going from mmx to float use
691          of the registers that are shared by both; note that
692          there is no float-to-mmx operation needed, because
693          only the float tag word info is corruptible)
694 */
695 #ifdef  MMX_TRACE
696
697 #define emms() \
698         { \
699                 fprintf(stderr, "emms()\n"); \
700                 __asm__ __volatile__ ("emms"); \
701         }
702
703 #else
704
705 #define emms()                  __asm__ __volatile__ ("emms")
706
707 #endif
708
709 #endif
710