ARB prog parser: Set NumAttributes based on the number of attribs read
[mesa.git] / src / mesa / x86 / mmx_blend.S
index f80cbf6c45e739b456fc7d70f71a296f4eefc085..eeaf43ea9370e9cd91558942877b746df4ff154d 100644 (file)
@@ -1,9 +1,12 @@
+       ;
 /*
- * Written by José Fonseca <j_r_fonseca@yahoo.co.uk>
+ * Written by Jos Fonseca <j_r_fonseca@yahoo.co.uk>
  */
 
-#include "matypes.h"
 
+#ifdef USE_MMX_ASM
+#include "assyntax.h"
+#include "matypes.h"
 
 /* integer multiplication - alpha plus one
  *
@@ -21,9 +24,9 @@
  */
 #define GMB_MULT_AP1( MP1, MA1, MP2, MA2, MX1 ) \
     PSUBW      ( MX1, MA1 )                    /*   a1 + 1  |   a1 + 1  |   a1 + 1  |   a1 + 1  */     ;\
-TWO(PSUBW      ( MX1, MA2 ))                   /*   a2 + 1  |   a2 + 1  |   a2 + 1  |   a2 + 1  */     ;\
-                                                                                                       ;\
     PMULLW     ( MP1, MA1 )                    /*                  t1 = p1*a1                   */     ;\
+                                                                                                       ;\
+TWO(PSUBW      ( MX1, MA2 ))                   /*   a2 + 1  |   a2 + 1  |   a2 + 1  |   a2 + 1  */     ;\
 TWO(PMULLW     ( MP2, MA2 ))                   /*                  t2 = p2*a2                   */     ;\
                                                                                                        ;\
     PSRLW      ( CONST(8), MA1 )               /*               t1 >> 8 ~= t1/255               */     ;\
@@ -48,15 +51,15 @@ TWO(PSRLW      ( CONST(8), MA2 ))           /*               t2 >> 8 ~= t2/255
 TWO(PMULLW     ( MP2, MA2 ))                   /*                  t2 = p2*a2                   */     ;\
                                                                                                        ;\
     MOVQ       ( MA1, MP1 )                                                                            ;\
-TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+    PSRLW      ( CONST(8), MA1 )               /*                    t1 >> 8                    */     ;\
                                                                                                        ;\
-    PSRLW      ( CONST(8), MP1 )               /*                    t1 >> 8                    */     ;\
-TWO(PSRLW      ( CONST(8), MP2 ))              /*                    t2 >> 8                    */     ;\
+TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+TWO(PSRLW      ( CONST(8), MA2 ))              /*                    t2 >> 8                    */     ;\
                                                                                                        ;\
     PADDW      ( MP1, MA1 )                    /*        t1 + (t1 >> 8) ~= (t1/255) << 8        */     ;\
-TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
-                                                                                                       ;\
     PSRLW      ( CONST(8), MA1 )               /*    sa1    |    sb1    |    sg1    |    sr1    */     ;\
+                                                                                                       ;\
+TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
 TWO(PSRLW      ( CONST(8), MA2 ))              /*    sa2    |    sb2    |    sg2    |    sr2    */
 
 
@@ -73,21 +76,21 @@ TWO(PSRLW      ( CONST(8), MA2 ))           /*    sa2    |    sb2    |    sg2    |    sr2
  */
 #define GMB_MULT_GSR( MP1, MA1, MP2, MA2, M80 ) \
     PMULLW     ( MP1, MA1 )                    /*                  t1 = p1*a1                   */     ;\
-TWO(PMULLW     ( MP2, MA2 ))                   /*                  t2 = p2*a2                   */     ;\
-                                                                                                       ;\
     PADDW      ( M80, MA1 )                    /*                 t1 += 0x80                    */     ;\
+                                                                                                       ;\
+TWO(PMULLW     ( MP2, MA2 ))                   /*                  t2 = p2*a2                   */     ;\
 TWO(PADDW      ( M80, MA2 ))                   /*                 t2 += 0x80                    */     ;\
                                                                                                        ;\
     MOVQ       ( MA1, MP1 )                                                                            ;\
-TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+    PSRLW      ( CONST(8), MA1 )               /*                    t1 >> 8                    */     ;\
                                                                                                        ;\
-    PSRLW      ( CONST(8), MP1 )               /*                    t1 >> 8                    */     ;\
-TWO(PSRLW      ( CONST(8), MP2 ))              /*                    t2 >> 8                    */     ;\
+TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+TWO(PSRLW      ( CONST(8), MA2 ))              /*                    t2 >> 8                    */     ;\
                                                                                                        ;\
     PADDW      ( MP1, MA1 )                    /*        t1 + (t1 >> 8) ~= (t1/255) << 8        */     ;\
-TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
-                                                                                                       ;\
     PSRLW      ( CONST(8), MA1 )               /*    sa1    |    sb1    |    sg1    |    sr1    */     ;\
+                                                                                                       ;\
+TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
 TWO(PSRLW      ( CONST(8), MA2 ))              /*    sa2    |    sb2    |    sg2    |    sr2    */
 
 
@@ -95,19 +98,18 @@ TWO(PSRLW      ( CONST(8), MA2 ))           /*    sa2    |    sb2    |    sg2    |    sr2
  */
 #define GMB_LERP_GS( MP1, MQ1, MA1, MP2, MQ2, MA2) \
     PSUBW      ( MQ1, MP1 )                     /* pa1 - qa1 | pb1 - qb1 | pg1 - qg1 | pr1 - qr1 */    ;\
-TWO(PSUBW      ( MQ2, MP2 ))                    /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */    ;\
-                                                                                                       ;\
     PSLLW      ( CONST(8), MQ1 )               /*                    q1 << 8                    */     ;\
-TWO(PSLLW      ( CONST(8), MQ2 ))              /*                    q2 << 8                    */     ;\
-                                                                                                       ;\
     PMULLW     ( MP1, MA1 )                    /*              t1 = (q1 - p1)*pa1               */     ;\
+                                                                                                       ;\
+TWO(PSUBW      ( MQ2, MP2 ))                    /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */    ;\
+TWO(PSLLW      ( CONST(8), MQ2 ))              /*                    q2 << 8                    */     ;\
 TWO(PMULLW     ( MP2, MA2 ))                   /*              t2 = (q2 - p2)*pa2               */     ;\
                                                                                                        ;\
     MOVQ       ( MA1, MP1 )                                                                            ;\
-TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+    PSRLW      ( CONST(8), MA1 )               /*                    t1 >> 8                    */     ;\
                                                                                                        ;\
-    PSRLW      ( CONST(8), MP1 )               /*                    t1 >> 8                    */     ;\
-TWO(PSRLW      ( CONST(8), MP2 ))              /*                    t2 >> 8                    */     ;\
+TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+TWO(PSRLW      ( CONST(8), MA2 ))              /*                    t2 >> 8                    */     ;\
                                                                                                        ;\
     PADDW      ( MP1, MA1 )                    /*        t1 + (t1 >> 8) ~= (t1/255) << 8        */     ;\
 TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
@@ -127,12 +129,11 @@ TWO(PSRLW      ( CONST(8), MA2 ))         /*    sa2    |    sb2    |    sg2    |    sr2
  */
 #define GMB_LERP_GSR( MP1, MQ1, MA1, MP2, MQ2, MA2, M80) \
     PSUBW      ( MQ1, MP1 )                     /* pa1 - qa1 | pb1 - qb1 | pg1 - qg1 | pr1 - qr1 */    ;\
-TWO(PSUBW      ( MQ2, MP2 ))                    /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */    ;\
-                                                                                                       ;\
     PSLLW      ( CONST(8), MQ1 )               /*                    q1 << 8                    */     ;\
-TWO(PSLLW      ( CONST(8), MQ2 ))              /*                    q2 << 8                    */     ;\
-                                                                                                       ;\
     PMULLW     ( MP1, MA1 )                    /*              t1 = (q1 - p1)*pa1               */     ;\
+                                                                                                       ;\
+TWO(PSUBW      ( MQ2, MP2 ))                    /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */    ;\
+TWO(PSLLW      ( CONST(8), MQ2 ))              /*                    q2 << 8                    */     ;\
 TWO(PMULLW     ( MP2, MA2 ))                   /*              t2 = (q2 - p2)*pa2               */     ;\
                                                                                                        ;\
     PSRLW      ( CONST(15), MP1 )              /*                 q1 > p1 ? 1 : 0               */     ;\
@@ -148,10 +149,10 @@ TWO(PSUBW      ( MP2, MA2 ))                      /*                  t2 -=? 0x100
 TWO(PADDW      ( M80, MA2 ))                   /*                 t2 += 0x80                    */     ;\
                                                                                                        ;\
     MOVQ       ( MA1, MP1 )                                                                            ;\
-TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+    PSRLW      ( CONST(8), MA1 )               /*                    t1 >> 8                    */     ;\
                                                                                                        ;\
-    PSRLW      ( CONST(8), MP1 )               /*                    t1 >> 8                    */     ;\
-TWO(PSRLW      ( CONST(8), MP2 ))              /*                    t2 >> 8                    */     ;\
+TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+TWO(PSRLW      ( CONST(8), MA2 ))              /*                    t2 >> 8                    */     ;\
                                                                                                        ;\
     PADDW      ( MP1, MA1 )                    /*        t1 + (t1 >> 8) ~= (t1/255) << 8        */     ;\
 TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
@@ -173,25 +174,24 @@ TWO(PSRLW      ( CONST(8), MA2 ))         /*    sa2    |    sb2    |    sg2    |    sr2
  */
 #define GMB_LERP_GSC( MP1, MQ1, MA1, MP2, MQ2, MA2) \
     PSUBW      ( MQ1, MP1 )                     /* pa1 - qa1 | pb1 - qb1 | pg1 - qg1 | pr1 - qr1 */    ;\
-TWO(PSUBW      ( MQ2, MP2 ))                    /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */    ;\
-                                                                                                       ;\
     PSLLW      ( CONST(8), MQ1 )               /*                    q1 << 8                    */     ;\
-TWO(PSLLW      ( CONST(8), MQ2 ))              /*                    q2 << 8                    */     ;\
-                                                                                                       ;\
     PMULLW     ( MP1, MA1 )                    /*              t1 = (q1 - p1)*pa1               */     ;\
+                                                                                                       ;\
+TWO(PSUBW      ( MQ2, MP2 ))                    /* pa2 - qa2 | pb2 - qb2 | pg2 - qg2 | pr2 - qr2 */    ;\
+TWO(PSLLW      ( CONST(8), MQ2 ))              /*                    q2 << 8                    */     ;\
 TWO(PMULLW     ( MP2, MA2 ))                   /*              t2 = (q2 - p2)*pa2               */     ;\
                                                                                                        ;\
     MOVQ       ( MA1, MP1 )                                                                            ;\
-TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+    PSRLW      ( CONST(8), MA1 )               /*                    t1 >> 8                    */     ;\
                                                                                                        ;\
-    PSRLW      ( CONST(8), MP1 )               /*                    t1 >> 8                    */     ;\
-TWO(PSRLW      ( CONST(8), MP2 ))              /*                    t2 >> 8                    */     ;\
+TWO(MOVQ       ( MA2, MP2 ))                                                                           ;\
+TWO(PSRLW      ( CONST(8), MA2 ))              /*                    t2 >> 8                    */     ;\
                                                                                                        ;\
-    PADDW      ( MP1, MA1 )                    /*        t1 + (t1 >> 8) ~= (t1/255) << 8        */     ;\
-TWO(PADDW      ( MP2, MA2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
+    PADDW      ( MA1, MP1 )                    /*        t1 + (t1 >> 8) ~= (t1/255) << 8        */     ;\
+    PSRLW      ( CONST(7), MA1 )               /*                    t1 >> 15                   */     ;\
                                                                                                        ;\
-    PSRLW      ( CONST(7), MP1 )               /*                    t1 >> 15                   */     ;\
-TWO(PSRLW      ( CONST(7), MP2 ))              /*                    t2 >> 15                   */     ;\
+TWO(PADDW      ( MA2, MP2 ))                   /*        t2 + (t2 >> 8) ~= (t2/255) << 8        */     ;\
+TWO(PSRLW      ( CONST(7), MA2 ))              /*                    t2 >> 15                   */     ;\
                                                                                                        ;\
     PADDW      ( MP1, MA1 )                    /*  t1 + (t1 >> 8) + (t1 >>15) ~= (t1/255) << 8  */     ;\
 TWO(PADDW      ( MP2, MA2 ))                   /*  t2 + (t2 >> 8) + (t2 >>15) ~= (t2/255) << 8  */     ;\
@@ -203,47 +203,29 @@ TWO(PADDW      ( MQ2, MA2 ))                      /*              (t2/255 + q2) << 8
 TWO(PSRLW      ( CONST(8), MA2 ))              /*    sa2    |    sb2    |    sg2    |    sr2    */
 
 
-/* common blending initialization code
- */
-#if 0  /* rounding not used */
-    SEG_DATA
-
-ALIGNDATA8
-const_80:
-       D_LONG 0x00800080, 0x00800080
-
-#define GMB_INIT( M00, M80 ) \
-    PXOR       ( M00, M00 )                    /*   0x0000  |   0x0000  |   0x0000  |   0x0000  */
-    MOVQ       ( CONTENT(const_80), M80 )      /*   0xffff  |   0xffff  |   0xffff  |   0xffff  */
-
-#else
-
-#define GMB_INIT( M00 ) \
-    PXOR       ( M00, M00 )                    /*   0x0000  |   0x0000  |   0x0000  |   0x0000  */
-
-#endif
-
-/* common blending loading code
+/* common blending setup code
  *
  * note that M00 is a register with 0x0000000000000000 constant which can be easily obtained making
  *
  *   PXOR      ( M00, M00 )
  */
-#define GMB_LOAD(rgba, dest, MP1, MQ1, MA1, MP2, MQ2, MA2, M00) \
-ONE(MOVD       ( REGIND(rgba), MP1 ))          /*     |     |     |     | qa1 | qb1 | qg1 | qr1 */     ;\
-ONE(MOVD       ( REGIND(dest), MQ1 ))          /*     |     |     |     | pa1 | pb1 | pg1 | pr1 */     ;\
-                                                                                                       ;\
-TWO(MOVQ       ( REGIND(rgba), MP1 ))          /* qa2 | qb2 | qg2 | qr2 | qa1 | qb1 | qg1 | qr1 */     ;\
-TWO(MOVQ       ( REGIND(dest), MQ1 ))          /* pa2 | pb2 | pg2 | pr2 | pa1 | pb1 | pg1 | pr1 */     ;\
+#define GMB_LOAD(rgba, dest, MPP, MQQ) \
+ONE(MOVD       ( REGIND(rgba), MPP ))          /*     |     |     |     | qa1 | qb1 | qg1 | qr1 */     ;\
+ONE(MOVD       ( REGIND(dest), MQQ ))          /*     |     |     |     | pa1 | pb1 | pg1 | pr1 */     ;\
                                                                                                        ;\
+TWO(MOVQ       ( REGIND(rgba), MPP ))          /* qa2 | qb2 | qg2 | qr2 | qa1 | qb1 | qg1 | qr1 */     ;\
+TWO(MOVQ       ( REGIND(dest), MQQ ))          /* pa2 | pb2 | pg2 | pr2 | pa1 | pb1 | pg1 | pr1 */
+
+#define GMB_UNPACK(MP1, MQ1, MP2, MQ2, M00) \
 TWO(MOVQ       ( MP1, MP2 ))                                                                           ;\
 TWO(MOVQ       ( MQ1, MQ2 ))                                                                           ;\
                                                                                                        ;\
     PUNPCKLBW  ( M00, MQ1 )                    /*    qa1    |    qb1    |    qg1    |    qr1    */     ;\
 TWO(PUNPCKHBW  ( M00, MQ2 ))                    /*    qa2    |    qb2    |    qg2    |    qr2    */    ;\
     PUNPCKLBW  ( M00, MP1 )                    /*    pa1    |    pb1    |    pg1    |    pr1    */     ;\
-TWO(PUNPCKHBW  ( M00, MP2 ))                    /*    pa2    |    pb2    |    pg2    |    pr2    */    ;\
-                                                                                                       ;\
+TWO(PUNPCKHBW  ( M00, MP2 ))                    /*    pa2    |    pb2    |    pg2    |    pr2    */
+
+#define GMB_ALPHA(MP1, MA1, MP2, MA2) \
     MOVQ       ( MP1, MA1 )                                                                            ;\
 TWO(MOVQ       ( MP2, MA2 ))                                                                           ;\
                                                                                                        ;\
@@ -252,31 +234,169 @@ TWO(PUNPCKHWD  ( MA2, MA2 ))                     /*    pa2    |    pa2    |           |
     PUNPCKHDQ  ( MA1, MA1 )                     /*    pa1    |    pa1    |    pa1    |    pa1    */    ;\
 TWO(PUNPCKHDQ  ( MA2, MA2 ))                    /*    pa2    |    pa2    |    pa2    |    pa2    */
 
-/* common blending storing code
+#define GMB_PACK( MS1, MS2 ) \
+    PACKUSWB   ( MS2, MS1 )                    /* sa2 | sb2 | sg2 | sr2 | sa1 | sb1 | sg1 | sr1 */     ;\
+
+#define GMB_STORE(rgba, MSS ) \
+ONE(MOVD       ( MSS, REGIND(rgba) ))          /*     |     |     |     | sa1 | sb1 | sg1 | sr1 */     ;\
+TWO(MOVQ       ( MSS, REGIND(rgba) ))          /* sa2 | sb2 | sg2 | sr2 | sa1 | sb1 | sg1 | sr1 */
+
+/* Kevin F. Quinn <kevquinn@gentoo.org> 2 July 2006
+ * Replace data segment constants with text-segment
+ * constants (via pushl/movq)
+    SEG_DATA
+
+ALIGNDATA8
+const_0080:
+    D_LONG 0x00800080, 0x00800080
+
+const_80:
+    D_LONG 0x80808080, 0x80808080
+*/
+#define const_0080_l 0x00800080
+#define const_0080_h 0x00800080
+#define const_80_l 0x80808080
+#define const_80_h 0x80808080
+
+    SEG_TEXT
+
+
+/* Blend transparency function
+ */
+
+#define TAG(x) CONCAT(x,_transparency)
+#define LLTAG(x) LLBL2(x,_transparency)
+
+#define INIT \
+    PXOR       ( MM0, MM0 )                    /*   0x0000  |   0x0000  |   0x0000  |   0x0000  */
+
+#define MAIN( rgba, dest ) \
+    GMB_LOAD( rgba, dest, MM1, MM2 )                                                                   ;\
+    GMB_UNPACK( MM1, MM2, MM4, MM5, MM0 )                                                              ;\
+    GMB_ALPHA( MM1, MM3, MM4, MM6 )                                                                    ;\
+    GMB_LERP_GSC( MM1, MM2, MM3, MM4, MM5, MM6 )                                                       ;\
+    GMB_PACK( MM3, MM6 )                                                                               ;\
+    GMB_STORE( rgba, MM3 )
+
+#include "mmx_blendtmp.h"
+
+
+/* Blend add function
+ *
+ * FIXME: Add some loop unrolling here...
  */
-#define GMB_STORE(rgba, MA1, MA2) \
-    PACKUSWB   ( MA2, MA1 )                    /* sa2 | sb2 | sg2 | sr2 | sa1 | sb1 | sg1 | sr1 */     ;\
-                                                                                                       ;\
-ONE(MOVD       ( MA1, REGIND(rgba) ))                                                                  ;\
-TWO(MOVQ       ( MA1, REGIND(rgba) ))
 
+#define TAG(x) CONCAT(x,_add)
+#define LLTAG(x) LLBL2(x,_add)
 
-   SEG_TEXT
+#define INIT
 
+#define MAIN( rgba, dest ) \
+ONE(MOVD       ( REGIND(rgba), MM1 ))          /*     |     |     |     | qa1 | qb1 | qg1 | qr1 */     ;\
+ONE(MOVD       ( REGIND(dest), MM2 ))          /*     |     |     |     | pa1 | pb1 | pg1 | pr1 */     ;\
+ONE(PADDUSB    ( MM2, MM1 ))                                                                           ;\
+ONE(MOVD       ( MM1, REGIND(rgba) ))          /*     |     |     |     | sa1 | sb1 | sg1 | sr1 */     ;\
+                                                                                                       ;\
+TWO(MOVQ       ( REGIND(rgba), MM1 ))          /* qa2 | qb2 | qg2 | qr2 | qa1 | qb1 | qg1 | qr1 */     ;\
+TWO(PADDUSB    ( REGIND(dest), MM1 ))          /* sa2 | sb2 | sg2 | sr2 | sa1 | sb1 | sg1 | sr1 */     ;\
+TWO(MOVQ       ( MM1, REGIND(rgba) ))
 
-/* common transparency blending mode
+#include "mmx_blendtmp.h"
+
+
+/* Blend min function
  */
 
-#define TAG(x) x##_transparency
+#define TAG(x) CONCAT(x,_min)
+#define LLTAG(x) LLBL2(x,_min)
 
+/* Kevin F. Quinn 2nd July 2006
+ * Replace data segment constants with text-segment instructions
+#define INIT \
+    MOVQ       ( CONTENT(const_80), MM7 )
+ */
 #define INIT \
-       GMB_INIT( MM0 )
+    PUSH_L     ( CONST(const_80_h) )           /* 0x80| 0x80| 0x80| 0x80| 0x80| 0x80| 0x80| 0x80*/     ;\
+    PUSH_L     ( CONST(const_80_l) )                                                                   ;\
+    MOVQ       ( REGIND(ESP), MM7 )                                                                    ;\
+    ADD_L      ( CONST(8), ESP)
 
-#define MAIN \
-       GMB_LOAD( EDI, ESI, MM1, MM2, MM3, MM4, MM5, MM6, MM0)                                          ;\
-       GMB_LERP_GSC( MM1, MM2, MM3, MM4, MM5, MM6 )                                                    ;\
-       GMB_STORE( EDI, MM3, MM6 )
+#define MAIN( rgba, dest ) \
+    GMB_LOAD( rgba, dest, MM1, MM2 )                                                                   ;\
+    MOVQ       ( MM1, MM3 )                                                                            ;\
+    MOVQ       ( MM2, MM4 )                                                                            ;\
+    PXOR       ( MM7, MM3 )                    /*              unsigned -> signed               */     ;\
+    PXOR       ( MM7, MM4 )                    /*              unsigned -> signed               */     ;\
+    PCMPGTB    ( MM3, MM4 )                    /*                 q > p ? 0xff : 0x00           */     ;\
+    PAND       ( MM4, MM1 )                    /*                 q > p ? p : 0                 */     ;\
+    PANDN      ( MM2, MM4 )                    /*                 q > p ? 0 : q                 */     ;\
+    POR        ( MM1, MM4 )                    /*                 q > p ? p : q                 */     ;\
+    GMB_STORE( rgba, MM4 )
 
 #include "mmx_blendtmp.h"
 
+
+/* Blend max function
+ */
+
+#define TAG(x) CONCAT(x,_max)
+#define LLTAG(x) LLBL2(x,_max)
+
+/* Kevin F. Quinn 2nd July 2006
+ * Replace data segment constants with text-segment instructions
+#define INIT \
+    MOVQ       ( CONTENT(const_80), MM7 )
+ */
+#define INIT \
+    PUSH_L     ( CONST(const_80_l) )           /* 0x80| 0x80| 0x80| 0x80| 0x80| 0x80| 0x80| 0x80*/     ;\
+    PUSH_L     ( CONST(const_80_h) )                                                                   ;\
+    MOVQ       ( REGIND(ESP), MM7 )                                                                    ;\
+    ADD_L      ( CONST(8), ESP)
+
+#define MAIN( rgba, dest ) \
+    GMB_LOAD( rgba, dest, MM1, MM2 )                                                                   ;\
+    MOVQ       ( MM1, MM3 )                                                                            ;\
+    MOVQ       ( MM2, MM4 )                                                                            ;\
+    PXOR       ( MM7, MM3 )                    /*              unsigned -> signed               */     ;\
+    PXOR       ( MM7, MM4 )                    /*              unsigned -> signed               */     ;\
+    PCMPGTB    ( MM3, MM4 )                    /*                 q > p ? 0xff : 0x00           */     ;\
+    PAND       ( MM4, MM2 )                    /*                 q > p ? q : 0                 */     ;\
+    PANDN      ( MM1, MM4 )                    /*                 q > p ? 0 : p                 */     ;\
+    POR        ( MM2, MM4 )                    /*                 q > p ? p : q                 */     ;\
+    GMB_STORE( rgba, MM4 )
+
+#include "mmx_blendtmp.h"
+
+
+/* Blend modulate function
+ */
+
+#define TAG(x) CONCAT(x,_modulate)
+#define LLTAG(x) LLBL2(x,_modulate)
+
+/* Kevin F. Quinn 2nd July 2006
+ * Replace data segment constants with text-segment instructions
+#define INIT \
+    MOVQ       ( CONTENT(const_0080), MM7 )
+ */
+#define INIT \
+    PXOR       ( MM0, MM0 )                    /*   0x0000  |   0x0000  |   0x0000  |   0x0000  */     ;\
+    PUSH_L     ( CONST(const_0080_l) )         /*   0x0080  |   0x0080  |   0x0080  |   0x0080  */     ;\
+    PUSH_L     ( CONST(const_0080_h) )                                                                 ;\
+    MOVQ       ( REGIND(ESP), MM7 )                                                                    ;\
+    ADD_L      ( CONST(8), ESP)
+
+#define MAIN( rgba, dest ) \
+    GMB_LOAD( rgba, dest, MM1, MM2 )                                                                   ;\
+    GMB_UNPACK( MM1, MM2, MM4, MM5, MM0 )                                                              ;\
+    GMB_MULT_GSR( MM1, MM2, MM4, MM5, MM7 )                                                            ;\
+    GMB_PACK( MM2, MM5 )                                                                               ;\
+    GMB_STORE( rgba, MM2 )
+
+#include "mmx_blendtmp.h"
+
+#endif
+       
+#if defined (__ELF__) && defined (__linux__)
+       .section .note.GNU-stack,"",%progbits
+#endif