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