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