updated Glide driver documentation

fixed SAL/SAR in assyntax.h (NASM)
fixed a bug wrt NULL pointer assignment in t_vtx_api.c
cosmetics to t_vtx_x86.c & t_vtx_x86_gcc.S
enabled STDCALL with codegen (MinGW)

6 files changed, 474 insertions, 288 deletions

diff --git a/src/mesa/Makefile.mgw b/src/mesa/Makefile.mgw
index 9084bf478b..a209e582d9 100644
--- a/src/mesa/Makefile.mgw
+++ b/src/mesa/Makefile.mgw
@@ -134,7 +134,7 @@ x86/matypes.h: x86/gen_matypes.exe
 x86/gen_matypes.exe: x86/gen_matypes.c
 	$(CC) -o $@ $(CFLAGS) -s $<
 
-# [dBorca] Hack alert:
+# [dBorca]
 # glapi_x86.S needs some adjustments
 # in order to generate correct entrypoints
 x86/glapi_x86.o: x86/glapi_x86.S
@@ -142,6 +142,11 @@ x86/glapi_x86.o: x86/glapi_x86.S
 #main/dispatch.o: main/dispatch.c
 #	$(CC) -o $@ $(CFLAGS) -UUSE_X86_ASM -c $<
 
+# [dBorca]
+# if we want codegen, we have to stdcall
+tnl/t_vtx_x86_gcc.o: tnl/t_vtx_x86_gcc.S
+	$(CC) -o $@ $(CFLAGS) -DSTDCALL_API -c $<
+
 clean:
 	-$(call UNLINK,array_cache/*.o)
 	-$(call UNLINK,glapi/*.o)
diff --git a/src/mesa/tnl/t_vtx_api.c b/src/mesa/tnl/t_vtx_api.c
index 0e28c73910..24ced9da18 100644
--- a/src/mesa/tnl/t_vtx_api.c
+++ b/src/mesa/tnl/t_vtx_api.c
@@ -102,8 +102,10 @@ static void _tnl_wrap_buffers( GLcontext *ctx )
 
 /* Deal with buffer wrapping where provoked by the vertex buffer
  * filling up, as opposed to upgrade_vertex().
+ *
+ * Make it GLAPIENTRY, so we can tail from the codegen'ed Vertex*fv
  */
-void _tnl_wrap_filled_vertex( GLcontext *ctx )
+void GLAPIENTRY _tnl_wrap_filled_vertex( GLcontext *ctx )
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    GLfloat *data = tnl->vtx.copied.buffer;
@@ -403,7 +405,7 @@ static attrfv_func do_choose( GLuint attr, GLuint sz )
 
 
    /* Try to use codegen:
-    */   
+    */
 #ifdef USE_X86_ASM
    if (tnl->AllowCodegen)
       tnl->vtx.tabfv[attr][sz-1] = do_codegen( ctx, attr, sz );
@@ -473,11 +475,15 @@ static void reset_attrfv( TNLcontext *tnl )
 
    for (i = 0 ; i < _TNL_ATTRIB_MAX ; i++) 
       if (tnl->vtx.attrsz[i]) {
-	 GLuint j = tnl->vtx.attrsz[i] - 1;
+	 GLint j = tnl->vtx.attrsz[i] - 1;
 	 tnl->vtx.attrsz[i] = 0;
 
-	 if (i < _TNL_MAX_ATTR_CODEGEN)
-	    tnl->vtx.tabfv[i][j] = choose[i][j];
+	 if (i < _TNL_MAX_ATTR_CODEGEN) {
+            while (j >= 0) {
+	       tnl->vtx.tabfv[i][j] = choose[i][j];
+               j--;
+            }
+         }
       }
 
    tnl->vtx.vertex_size = 0;
diff --git a/src/mesa/tnl/t_vtx_api.h b/src/mesa/tnl/t_vtx_api.h
index f58461332e..97d5cf5563 100644
--- a/src/mesa/tnl/t_vtx_api.h
+++ b/src/mesa/tnl/t_vtx_api.h
@@ -49,7 +49,7 @@ extern void _tnl_vtx_destroy( GLcontext *ctx );
 extern void _tnl_FlushVertices( GLcontext *ctx, GLuint flags );
 extern void _tnl_flush_vtx( GLcontext *ctx );
 
-extern void _tnl_wrap_filled_vertex( GLcontext *ctx );
+extern void GLAPIENTRY _tnl_wrap_filled_vertex( GLcontext *ctx );
 
 /* t_vtx_exec.c:
  */
diff --git a/src/mesa/tnl/t_vtx_x86.c b/src/mesa/tnl/t_vtx_x86.c
index 5aafedebbe..5d7f95e98b 100644
--- a/src/mesa/tnl/t_vtx_x86.c
+++ b/src/mesa/tnl/t_vtx_x86.c
@@ -60,22 +60,25 @@ EXTERN( _tnl_x86_Vertex2fv );
 EXTERN( _tnl_x86_Vertex3fv );
 EXTERN( _tnl_x86_Vertex4fv );
 
-EXTERN( _tnl_x86_dispatch_attrf );
+EXTERN( _tnl_x86_dispatch_attrf1 );
+EXTERN( _tnl_x86_dispatch_attrf2 );
+EXTERN( _tnl_x86_dispatch_attrf3 );
+EXTERN( _tnl_x86_dispatch_attrf4 );
 EXTERN( _tnl_x86_dispatch_attrfv );
-EXTERN( _tnl_x86_dispatch_multitexcoordf );
+EXTERN( _tnl_x86_dispatch_multitexcoordf1 );
+EXTERN( _tnl_x86_dispatch_multitexcoordf2 );
+EXTERN( _tnl_x86_dispatch_multitexcoordf3 );
+EXTERN( _tnl_x86_dispatch_multitexcoordf4 );
 EXTERN( _tnl_x86_dispatch_multitexcoordfv );
-EXTERN( _tnl_x86_dispatch_vertexattribf );
+EXTERN( _tnl_x86_dispatch_vertexattribf1 );
+EXTERN( _tnl_x86_dispatch_vertexattribf2 );
+EXTERN( _tnl_x86_dispatch_vertexattribf3 );
+EXTERN( _tnl_x86_dispatch_vertexattribf4 );
 EXTERN( _tnl_x86_dispatch_vertexattribfv );
 
 EXTERN( _tnl_x86_choose_fv );
 
 
-static void notify( void )
-{
-   GET_CURRENT_CONTEXT( ctx );
-   _tnl_wrap_filled_vertex( ctx );
-}
-
 #define DONT_KNOW_OFFSETS 1
 
 
@@ -93,7 +96,7 @@ static void notify( void )
 
 #define FIXUP( CODE, KNOWN_OFFSET, CHECKVAL, NEWVAL )	\
 do {							\
-   GLuint subst = 0x10101010 + CHECKVAL;		\
+   GLint subst = 0x10101010 + CHECKVAL;			\
 							\
    if (DONT_KNOW_OFFSETS) {				\
       while (*(int *)(CODE+offset) != subst) offset++;	\
@@ -112,7 +115,7 @@ do {							\
 
 #define FIXUPREL( CODE, KNOWN_OFFSET, CHECKVAL, NEWVAL )\
 do {							\
-   GLuint subst = 0x10101010 + CHECKVAL;		\
+   GLint subst = 0x10101010 + CHECKVAL;			\
 							\
    if (DONT_KNOW_OFFSETS) {				\
       while (*(int *)(CODE+offset) != subst) offset++;	\
@@ -262,53 +265,16 @@ void _tnl_InitX86Codegen( struct _tnl_dynfn_generators *gen )
 }
 
 
-static attrfv_func
-_do_choose( GLuint attr, GLuint sz )
-{
-   return NULL;
-}
-
-
-/* I purposely avoided one single macro, since they might need to be
- * handled in different ways.  Ohwell, once things get much clearer,
- * they could collapse...
- */
-#define MAKE_DISPATCH_ATTR(FUNC, SIZE, TYPE, ATTR)			\
+#define MKDISP(FUNC, SIZE, ATTR, WARP)					\
 do {									\
    char *code;								\
-   char *start = (char *)&_tnl_x86_dispatch_attr##TYPE;			\
-   char *end = (char *)&_tnl_x86_dispatch_attr##TYPE##_end;		\
+   char *start = (char *)&WARP;						\
+   char *end = (char *)&WARP##_end;					\
    int offset = 0;							\
    code = ALIGN_MALLOC( end - start, 16 );				\
    memcpy (code, start, end - start);					\
    FIXUP(code, 0, 0, (int)&(TNL_CONTEXT(ctx)->vtx.tabfv[ATTR][SIZE-1]));\
-   vfmt->FUNC##SIZE##TYPE = code;					\
-} while (0)
-
-
-#define MAKE_DISPATCH_MULTITEXCOORD(FUNC, SIZE, TYPE, ATTR)		\
-do {									\
-   char *code;								\
-   char *start = (char *)&_tnl_x86_dispatch_multitexcoord##TYPE;	\
-   char *end = (char *)&_tnl_x86_dispatch_multitexcoord##TYPE##_end;	\
-   int offset = 0;							\
-   code = ALIGN_MALLOC( end - start, 16 );				\
-   memcpy (code, start, end - start);					\
-   FIXUP(code, 0, 0, (int)&(TNL_CONTEXT(ctx)->vtx.tabfv[_TNL_ATTRIB_TEX0][SIZE-1]));\
-   vfmt->FUNC##SIZE##TYPE##ARB = code;					\
-} while (0)
-
-
-#define MAKE_DISPATCH_VERTEXATTRIB(FUNC, SIZE, TYPE, ATTR)		\
-do {									\
-   char *code;								\
-   char *start = (char *)&_tnl_x86_dispatch_vertexattrib##TYPE;		\
-   char *end = (char *)&_tnl_x86_dispatch_vertexattrib##TYPE##_end;	\
-   int offset = 0;							\
-   code = ALIGN_MALLOC( end - start, 16 );				\
-   memcpy (code, start, end - start);					\
-   FIXUP(code, 0, 0, (int)&(TNL_CONTEXT(ctx)->vtx.tabfv[0][SIZE-1]));	\
-   vfmt->FUNC##SIZE##TYPE##NV = code;					\
+   *(void **)&vfmt->FUNC = code;					\
 } while (0)
 
 
@@ -319,48 +285,48 @@ void _tnl_x86_exec_vtxfmt_init( GLcontext *ctx )
 {
    GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->exec_vtxfmt);
 
-   MAKE_DISPATCH_ATTR(Color,3,f,     _TNL_ATTRIB_COLOR0);
-   MAKE_DISPATCH_ATTR(Color,3,fv,    _TNL_ATTRIB_COLOR0);
-   MAKE_DISPATCH_ATTR(Color,4,f,     _TNL_ATTRIB_COLOR0);
-   MAKE_DISPATCH_ATTR(Color,4,fv,    _TNL_ATTRIB_COLOR0);
-/* vfmt->FogCoordfEXT = _tnl_FogCoordfEXT;
-   vfmt->FogCoordfvEXT = _tnl_FogCoordfvEXT;*/
-   MAKE_DISPATCH_ATTR(Normal,3,f,    _TNL_ATTRIB_NORMAL);
-   MAKE_DISPATCH_ATTR(Normal,3,fv,   _TNL_ATTRIB_NORMAL);
-/* vfmt->SecondaryColor3fEXT = _tnl_SecondaryColor3fEXT;
-   vfmt->SecondaryColor3fvEXT = _tnl_SecondaryColor3fvEXT; */
-   MAKE_DISPATCH_ATTR(TexCoord,1,f,  _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,1,fv, _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,2,f,  _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,2,fv, _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,3,f,  _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,3,fv, _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,4,f,  _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(TexCoord,4,fv, _TNL_ATTRIB_TEX0);
-   MAKE_DISPATCH_ATTR(Vertex,2,f,    _TNL_ATTRIB_POS);
-   MAKE_DISPATCH_ATTR(Vertex,2,fv,   _TNL_ATTRIB_POS);
-   MAKE_DISPATCH_ATTR(Vertex,3,f,    _TNL_ATTRIB_POS);
-   MAKE_DISPATCH_ATTR(Vertex,3,fv,   _TNL_ATTRIB_POS);
-   MAKE_DISPATCH_ATTR(Vertex,4,f,    _TNL_ATTRIB_POS);
-   MAKE_DISPATCH_ATTR(Vertex,4,fv,   _TNL_ATTRIB_POS);
-
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,1,f,  0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,1,fv, 0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,2,f,  0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,2,fv, 0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,3,f,  0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,3,fv, 0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,4,f,  0);
-   MAKE_DISPATCH_MULTITEXCOORD(MultiTexCoord,4,fv, 0);
-
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,1,f,  0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,1,fv, 0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,2,f,  0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,2,fv, 0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,3,f,  0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,3,fv, 0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,4,f,  0);
-   MAKE_DISPATCH_VERTEXATTRIB(VertexAttrib,4,fv, 0);
+   MKDISP(Color3f,             3, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrf3);
+   MKDISP(Color3fv,            3, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrfv);
+   MKDISP(Color4f,             4, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrf4);
+   MKDISP(Color4fv,            4, _TNL_ATTRIB_COLOR0, _tnl_x86_dispatch_attrfv);
+   MKDISP(FogCoordfEXT,        1, _TNL_ATTRIB_FOG,    _tnl_x86_dispatch_attrf1);
+   MKDISP(FogCoordfvEXT,       1, _TNL_ATTRIB_FOG,    _tnl_x86_dispatch_attrfv);
+   MKDISP(Normal3f,            3, _TNL_ATTRIB_NORMAL, _tnl_x86_dispatch_attrf3);
+   MKDISP(Normal3fv,           3, _TNL_ATTRIB_NORMAL, _tnl_x86_dispatch_attrfv);
+   MKDISP(SecondaryColor3fEXT, 3, _TNL_ATTRIB_COLOR1, _tnl_x86_dispatch_attrf3);
+   MKDISP(SecondaryColor3fvEXT,3, _TNL_ATTRIB_COLOR1, _tnl_x86_dispatch_attrfv);
+   MKDISP(TexCoord1f,          1, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrf1);
+   MKDISP(TexCoord1fv,         1, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrfv);
+   MKDISP(TexCoord2f,          2, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrf2);
+   MKDISP(TexCoord2fv,         2, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrfv);
+   MKDISP(TexCoord3f,          3, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrf3);
+   MKDISP(TexCoord3fv,         3, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrfv);
+   MKDISP(TexCoord4f,          4, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrf4);
+   MKDISP(TexCoord4fv,         4, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_attrfv);
+   MKDISP(Vertex2f,            2, _TNL_ATTRIB_POS,    _tnl_x86_dispatch_attrf2);
+   MKDISP(Vertex2fv,           2, _TNL_ATTRIB_POS,    _tnl_x86_dispatch_attrfv);
+   MKDISP(Vertex3f,            3, _TNL_ATTRIB_POS,    _tnl_x86_dispatch_attrf3);
+   MKDISP(Vertex3fv,           3, _TNL_ATTRIB_POS,    _tnl_x86_dispatch_attrfv);
+   MKDISP(Vertex4f,            4, _TNL_ATTRIB_POS,    _tnl_x86_dispatch_attrf4);
+   MKDISP(Vertex4fv,           4, _TNL_ATTRIB_POS,    _tnl_x86_dispatch_attrfv);
+
+   MKDISP(MultiTexCoord1fARB,  1, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordf1);
+   MKDISP(MultiTexCoord1fvARB, 1, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordfv);
+   MKDISP(MultiTexCoord2fARB,  2, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordf2);
+   MKDISP(MultiTexCoord2fvARB, 2, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordfv);
+   MKDISP(MultiTexCoord3fARB,  3, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordf3);
+   MKDISP(MultiTexCoord3fvARB, 3, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordfv);
+   MKDISP(MultiTexCoord4fARB,  4, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordf4);
+   MKDISP(MultiTexCoord4fvARB, 4, _TNL_ATTRIB_TEX0,   _tnl_x86_dispatch_multitexcoordfv);
+
+   MKDISP(VertexAttrib1fNV,    1, 0,                  _tnl_x86_dispatch_vertexattribf1);
+   MKDISP(VertexAttrib1fvNV,   1, 0,                  _tnl_x86_dispatch_vertexattribfv);
+   MKDISP(VertexAttrib2fNV,    2, 0,                  _tnl_x86_dispatch_vertexattribf2);
+   MKDISP(VertexAttrib2fvNV,   2, 0,                  _tnl_x86_dispatch_vertexattribfv);
+   MKDISP(VertexAttrib3fNV,    3, 0,                  _tnl_x86_dispatch_vertexattribf3);
+   MKDISP(VertexAttrib3fvNV,   3, 0,                  _tnl_x86_dispatch_vertexattribfv);
+   MKDISP(VertexAttrib4fNV,    4, 0,                  _tnl_x86_dispatch_vertexattribf4);
+   MKDISP(VertexAttrib4fvNV,   4, 0,                  _tnl_x86_dispatch_vertexattribfv);
 }
 
 
@@ -384,7 +350,7 @@ void _tnl_x86choosers( attrfv_func (*choose)[4],
          FIXUP(code, 0, 0, attr);
          FIXUP(code, 0, 1, size + 1);
          FIXUPREL(code, 0, 2, do_choose);
-         choose[attr][size] = code;
+         choose[attr][size] = (attrfv_func)code;
       }
    }
 }
diff --git a/src/mesa/tnl/t_vtx_x86_gcc.S b/src/mesa/tnl/t_vtx_x86_gcc.S
index bad87d3ee9..fcc69f1d0d 100644
--- a/src/mesa/tnl/t_vtx_x86_gcc.S
+++ b/src/mesa/tnl/t_vtx_x86_gcc.S
@@ -28,97 +28,114 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 /*
  * Authors:
  *   Keith Whitwell <keith@tungstengraphics.com>
+ *   Daniel Borca <dborca@yahoo.com>
  */
 
-#if !defined (__DJGPP__) && !defined (__MINGW32__)
-
+#if defined (__DJGPP__) || defined (__MINGW32__)
+#define GLOBL( x )	\
+.globl _##x;		\
+_##x:
+#else  /* !defined (__DJGPP__) && !defined (__MINGW32__) */
 #define GLOBL( x )	\
 .globl x;		\
 x:
+#endif /* !defined (__DJGPP__) && !defined (__MINGW32__) */
 
-#else  /* defined(__DJGPP__) || defined (__MINGW32__) */
 
-#define GLOBL( x )	\
-.globl _##x;		\
-_##x:
+#if !defined (STDCALL_API)
+#define RETCLEAN( x )	ret
+#else
+#define RETCLEAN( x )	ret $x
+#endif
 
-#endif /* defined(__DJGPP__) || defined (__MINGW32__) */
 
-.data
-.align 4
+#define _JMP(x)		\
+.byte 0xe9;		\
+.long x
+
+#define _CALL(x)	\
+.byte 0xe8;		\
+.long x
 
-// Someone who knew a lot about this sort of thing would use this
-// macro to note current offsets, etc in a special region of the
-// object file & just make everything work out neat.  I do not know
-// enough to do that...
+
+/* Someone who knew a lot about this sort of thing would use this
+ * macro to note current offsets, etc in a special region of the
+ * object file & just make everything work out neat.  I don't know
+ * enough to do that...
+ */
 
 #define SUBST( x ) (0x10101010 + x)
 
 
+.data
 
-// [dBorca] TODO
-// Unfold functions for each vertex size?
-// Build super-specialized SSE versions?
-// STDCALL woes (HAVE_NONSTANDARD_GLAPIENTRY):
-//   need separate routine for the non "fv" case,
-//   to clean up the stack!
 
+/* [dBorca] TODO
+ * Unfold functions for each vertex size?
+ * Build super-specialized SSE versions?
+ *
+ * There is a trick in Vertex*fv: under certain conditions,
+ * we tail to _tnl_wrap_filled_vertex(ctx). This means that
+ * if Vertex*fv is STDCALL, then _tnl_wrap_filled_vertex must
+ * be STDCALL as well, because (GLcontext *) and (GLfloat *)
+ * have the same size.
+ */
+.align 4
 GLOBL ( _tnl_x86_Vertex1fv )
 	movl	4(%esp), %ecx
 	push	%edi
 	push	%esi
-	movl	SUBST(0), %edi	# 0x0 --> tnl->vtx.vbptr
-	movl	(%ecx), %edx	# load v[0]
-	movl	%edx, (%edi)	# tnl->vtx.vbptr[0] = v[0]
-	addl	$4, %edi	# tnl->vtx.vbptr += 1
-	movl	$SUBST(1), %ecx	# 0x1 --> (tnl->vtx.vertex_size - 1)
-	movl	$SUBST(2), %esi	# 0x2 --> (tnl->vtx.vertex + 1)
+	movl	SUBST(0), %edi	/* 0x0 --> tnl->vtx.vbptr */
+	movl	(%ecx), %edx	/* load v[0] */
+	movl	%edx, (%edi)	/* tnl->vtx.vbptr[0] = v[0] */
+	addl	$4, %edi	/* tnl->vtx.vbptr += 1 */
+	movl	$SUBST(1), %ecx	/* 0x1 --> (tnl->vtx.vertex_size - 1) */
+	movl	$SUBST(2), %esi	/* 0x2 --> (tnl->vtx.vertex + 1) */
 	repz
 	movsl	%ds:(%esi), %es:(%edi)
-	movl	%edi, SUBST(0)	# 0x0 --> tnl->vtx.vbptr
-	movl	SUBST(3), %edx	# 0x3 --> counter
+	movl	%edi, SUBST(0)	/* 0x0 --> tnl->vtx.vbptr */
+	movl	SUBST(3), %edx	/* 0x3 --> counter */
 	pop	%esi
 	pop	%edi
-	dec	%edx		# counter--
-	movl	%edx, SUBST(3)	# 0x3 --> counter
-	jne	.0		# if (counter != 0) return
-	pushl	$SUBST(4)	# 0x4 --> ctx
-	.byte	0xe8		# call ...
-	.long	SUBST(5)	# ... _tnl_wrap_filled_vertex(ctx)
-	pop	%eax
+	dec	%edx		/* counter-- */
+	movl	%edx, SUBST(3)	/* 0x3 --> counter */
+	je	.0		/* if (counter == 0) goto .0 */
+	RETCLEAN(4)		/* return */
+	.balign	16
 .0:
-	ret			# return
+	movl	$SUBST(4), %eax	/* load ctx */
+	movl	%eax, 4(%esp)	/* push ctx */
+	_JMP	(SUBST(5))	/* jmp _tnl_wrap_filled_vertex */
 GLOBL ( _tnl_x86_Vertex1fv_end )
 
-
 .align 4
 GLOBL ( _tnl_x86_Vertex2fv )
 	movl	4(%esp), %ecx
 	push	%edi
 	push	%esi
-	movl	SUBST(0), %edi	# load tnl->vtx.vbptr
-	movl	(%ecx), %edx	# load v[0]
-	movl	4(%ecx), %eax	# load v[1]
-	movl	%edx, (%edi)	# tnl->vtx.vbptr[0] = v[0]
-	movl	%eax, 4(%edi)	# tnl->vtx.vbptr[1] = v[1]
-	addl	$8, %edi	# tnl->vtx.vbptr += 2
-	movl	$SUBST(1), %ecx	# vertex_size - 2
-	movl	$SUBST(2), %esi	# tnl->vtx.vertex + 2
+	movl	SUBST(0), %edi	/* load tnl->vtx.vbptr */
+	movl	(%ecx), %edx	/* load v[0] */
+	movl	4(%ecx), %eax	/* load v[1] */
+	movl	%edx, (%edi)	/* tnl->vtx.vbptr[0] = v[0] */
+	movl	%eax, 4(%edi)	/* tnl->vtx.vbptr[1] = v[1] */
+	addl	$8, %edi	/* tnl->vtx.vbptr += 2 */
+	movl	$SUBST(1), %ecx	/* vertex_size - 2 */
+	movl	$SUBST(2), %esi	/* tnl->vtx.vertex + 2 */
 	repz
 	movsl	%ds:(%esi), %es:(%edi)
-	movl	%edi, SUBST(0)	# save tnl->vtx.vbptr
-	movl	SUBST(3), %edx	# load counter
+	movl	%edi, SUBST(0)	/* save tnl->vtx.vbptr */
+	movl	SUBST(3), %edx	/* load counter */
 	pop	%esi
 	pop	%edi
-	dec	%edx		# counter--
-	movl	%edx, SUBST(3)	# save counter
-	jne	.1		# if (counter != 0) return
-	pushl	$SUBST(4)	# load ctx
-	.byte	0xe8		# call ...
-	.long	SUBST(5)	# ... _tnl_wrap_filled_vertex(ctx)
-	pop	%eax
+	dec	%edx		/* counter-- */
+	movl	%edx, SUBST(3)	/* save counter */
+	je	.1		/* if (counter == 0) goto .1 */
+	RETCLEAN(4)		/* return */
+	.balign	16
 .1:
-	ret			# return
+	movl	$SUBST(4), %eax	/* load ctx */
+	movl	%eax, 4(%esp)	/* push ctx */
+	_JMP	(SUBST(5))	/* jmp _tnl_wrap_filled_vertex */
 GLOBL ( _tnl_x86_Vertex2fv_end )
 
 .align 4
@@ -126,92 +143,88 @@ GLOBL ( _tnl_x86_Vertex3fv )
 	movl	4(%esp), %ecx
 	push	%edi
 	push	%esi
-	movl	SUBST(0), %edi	# load tnl->vtx.vbptr
-	movl	(%ecx), %edx	# load v[0]
-	movl	4(%ecx), %eax	# load v[1]
-	movl	8(%ecx), %esi	# load v[2]
-	movl	%edx, (%edi)	# tnl->vtx.vbptr[0] = v[0]
-	movl	%eax, 4(%edi)	# tnl->vtx.vbptr[1] = v[1]
-	movl	%esi, 8(%edi)	# tnl->vtx.vbptr[2] = v[2]
-	addl	$12, %edi	# tnl->vtx.vbptr += 3
-	movl	$SUBST(1), %ecx	# vertex_size - 3
-	movl	$SUBST(2), %esi	# tnl->vtx.vertex + 3
+	movl	SUBST(0), %edi	/* load tnl->vtx.vbptr */
+	movl	(%ecx), %edx	/* load v[0] */
+	movl	4(%ecx), %eax	/* load v[1] */
+	movl	8(%ecx), %esi	/* load v[2] */
+	movl	%edx, (%edi)	/* tnl->vtx.vbptr[0] = v[0] */
+	movl	%eax, 4(%edi)	/* tnl->vtx.vbptr[1] = v[1] */
+	movl	%esi, 8(%edi)	/* tnl->vtx.vbptr[2] = v[2] */
+	addl	$12, %edi	/* tnl->vtx.vbptr += 3 */
+	movl	$SUBST(1), %ecx	/* vertex_size - 3 */
+	movl	$SUBST(2), %esi	/* tnl->vtx.vertex + 3 */
 	repz
 	movsl	%ds:(%esi), %es:(%edi)
-	movl	%edi, SUBST(0)	# save tnl->vtx.vbptr
-	movl	SUBST(3), %edx	# load counter
+	movl	%edi, SUBST(0)	/* save tnl->vtx.vbptr */
+	movl	SUBST(3), %edx	/* load counter */
 	pop	%esi
 	pop	%edi
-	dec	%edx		# counter--
-	movl	%edx, SUBST(3)	# save counter
-	jne	.2		# if (counter != 0) return
-	pushl	$SUBST(4)	# load ctx
-	.byte	0xe8		# call ...
-	.long	SUBST(5)	# ... _tnl_wrap_filled_vertex(ctx)
-	pop	%eax
+	dec	%edx		/* counter-- */
+	movl	%edx, SUBST(3)	/* save counter */
+	je	.2		/* if (counter == 0) goto .2 */
+	RETCLEAN(4)		/* return */
+	.balign	16
 .2:
-	ret			# return
+	movl	$SUBST(4), %eax	/* load ctx */
+	movl	%eax, 4(%esp)	/* push ctx */
+	_JMP	(SUBST(5))	/* jmp _tnl_wrap_filled_vertex */
 GLOBL ( _tnl_x86_Vertex3fv_end )
 
-
 .align 4
 GLOBL ( _tnl_x86_Vertex4fv )
 	movl	4(%esp), %ecx
 	push	%edi
 	push	%esi
-	movl	SUBST(0), %edi	# load tnl->vtx.vbptr
-	movl	(%ecx), %edx	# load v[0]
-	movl	4(%ecx), %eax	# load v[1]
-	movl	8(%ecx), %esi	# load v[2]
-	movl	12(%ecx), %ecx	# load v[3]
-	movl	%edx, (%edi)	# tnl->vtx.vbptr[0] = v[0]
-	movl	%eax, 4(%edi)	# tnl->vtx.vbptr[1] = v[1]
-	movl	%esi, 8(%edi)	# tnl->vtx.vbptr[2] = v[2]
-	movl	%ecx, 12(%edi)	# tnl->vtx.vbptr[3] = v[3]
-	addl	$16, %edi	# tnl->vtx.vbptr += 4
-	movl	$SUBST(1), %ecx	# vertex_size - 4
-	movl	$SUBST(2), %esi	# tnl->vtx.vertex + 3
+	movl	SUBST(0), %edi	/* load tnl->vtx.vbptr */
+	movl	(%ecx), %edx	/* load v[0] */
+	movl	4(%ecx), %eax	/* load v[1] */
+	movl	8(%ecx), %esi	/* load v[2] */
+	movl	12(%ecx), %ecx	/* load v[3] */
+	movl	%edx, (%edi)	/* tnl->vtx.vbptr[0] = v[0] */
+	movl	%eax, 4(%edi)	/* tnl->vtx.vbptr[1] = v[1] */
+	movl	%esi, 8(%edi)	/* tnl->vtx.vbptr[2] = v[2] */
+	movl	%ecx, 12(%edi)	/* tnl->vtx.vbptr[3] = v[3] */
+	addl	$16, %edi	/* tnl->vtx.vbptr += 4 */
+	movl	$SUBST(1), %ecx	/* vertex_size - 4 */
+	movl	$SUBST(2), %esi	/* tnl->vtx.vertex + 4 */
 	repz
 	movsl	%ds:(%esi), %es:(%edi)
-	movl	%edi, SUBST(0)	# save tnl->vtx.vbptr
-	movl	SUBST(3), %edx	# load counter
+	movl	%edi, SUBST(0)	/* save tnl->vtx.vbptr */
+	movl	SUBST(3), %edx	/* load counter */
 	pop	%esi
 	pop	%edi
-	dec	%edx		# counter--
-	movl	%edx, SUBST(3)	# save counter
-	jne	.3		# if (counter != 0) return
-	pushl	$SUBST(4)	# load ctx
-	.byte	0xe8		# call ...
-	.long	SUBST(5)	# ... _tnl_wrap_filled_vertex(ctx)
-	pop	%eax
+	dec	%edx		/* counter-- */
+	movl	%edx, SUBST(3)	/* save counter */
+	je	.3		/* if (counter == 0) goto .3 */
+	RETCLEAN(4)		/* return */
+	.balign	16
 .3:
-	ret			# return
+	movl	$SUBST(4), %eax	/* load ctx */
+	movl	%eax, 4(%esp)	/* push ctx */
+	_JMP	(SUBST(5))	/* jmp _tnl_wrap_filled_vertex */
 GLOBL ( _tnl_x86_Vertex4fv_end )
 
 
-
 /**
  * Generic handlers for vector format data. 
  */
-
-GLOBL( _tnl_x86_Attribute1fv)
+GLOBL( _tnl_x86_Attribute1fv )
 	movl	4(%esp), %ecx
 	movl	(%ecx), %eax	/* load v[0] */
 	movl	%eax, SUBST(0)	/* store v[0] to current vertex */
-	ret
+	RETCLEAN(4)
 GLOBL ( _tnl_x86_Attribute1fv_end )
 
-GLOBL( _tnl_x86_Attribute2fv)
+GLOBL( _tnl_x86_Attribute2fv )
 	movl	4(%esp), %ecx
 	movl	(%ecx), %eax	/* load v[0] */
 	movl	4(%ecx), %edx	/* load v[1] */
 	movl	%eax, SUBST(0)	/* store v[0] to current vertex */
 	movl	%edx, SUBST(1)	/* store v[1] to current vertex */
-	ret
+	RETCLEAN(4)
 GLOBL ( _tnl_x86_Attribute2fv_end )
 
-
-GLOBL( _tnl_x86_Attribute3fv)
+GLOBL( _tnl_x86_Attribute3fv )
 	movl	4(%esp), %ecx
 	movl	(%ecx), %eax	/* load v[0] */
 	movl	4(%ecx), %edx	/* load v[1] */
@@ -219,10 +232,10 @@ GLOBL( _tnl_x86_Attribute3fv)
 	movl	%eax, SUBST(0)	/* store v[0] to current vertex */
 	movl	%edx, SUBST(1)	/* store v[1] to current vertex */
 	movl	%ecx, SUBST(2)	/* store v[2] to current vertex */
-	ret
+	RETCLEAN(4)
 GLOBL ( _tnl_x86_Attribute3fv_end )
 
-GLOBL( _tnl_x86_Attribute4fv)
+GLOBL( _tnl_x86_Attribute4fv )
 	movl	4(%esp), %ecx
 	movl	(%ecx), %eax	/* load v[0] */
 	movl	4(%ecx), %edx	/* load v[1] */
@@ -232,84 +245,131 @@ GLOBL( _tnl_x86_Attribute4fv)
 	movl	12(%ecx), %edx	/* load v[3] */
 	movl	%eax, SUBST(2)	/* store v[2] to current vertex */
 	movl	%edx, SUBST(3)	/* store v[3] to current vertex */
-	ret
+	RETCLEAN(4)
 GLOBL ( _tnl_x86_Attribute4fv_end )
 
 
-// Choosers:
-
-// Must generate all of these ahead of first usage.  Generate at
-// compile-time?  
-
-
-GLOBL( _tnl_x86_choose_fv)
-	subl	$12, %esp	# gcc does 16 byte alignment of stack frames?
-	movl	$SUBST(0), (%esp)	# arg 0 - attrib
-	movl	$SUBST(1), 4(%esp)	# arg 1 - N
-	.byte	0xe8			# call ...
-	.long	SUBST(2)		# ... do_choose
-	add	$12, %esp		# tear down stack frame
-	jmp	*%eax			# jump to new func
+/* Choosers:
+ *
+ * Must generate all of these ahead of first usage.  Generate at
+ * compile-time?
+ */
+GLOBL( _tnl_x86_choose_fv )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	$SUBST(0), (%esp)	/* arg 0 - attrib */
+	movl	$SUBST(1), 4(%esp)	/* arg 1 - N */
+	_CALL	(SUBST(2))		/* call do_choose */
+	add	$12, %esp		/* tear down stack frame */
+	jmp	*%eax			/* jump to new func */
 GLOBL ( _tnl_x86_choose_fv_end )
 
 
+/* FIRST LEVEL FUNCTIONS -- these are plugged directly into GL dispatch.
+ *
+ * In the 1st level dispatch functions, switch to a different
+ * calling convention -- (const GLfloat *v) in %ecx.
+ *
+ * As with regular (x86) dispatch, don't create a new stack frame -
+ * just let the 'ret' in the dispatched function return straight
+ * back to the original caller.
+ *
+ * Vertex/Normal/Color, etc: the address of the function pointer
+ * is known at codegen time.
+ */
 
-// FIRST LEVEL FUNCTIONS -- these are plugged directly into GL dispatch.
-
-
-
-// In the 1st level dispatch functions, switch to a different
-// calling convention -- (const GLfloat *v) in %ecx.
-// 
-// As with regular (x86) dispatch, do not create a new stack frame -
-// just let the 'ret' in the dispatched function return straight
-// back to the original caller.
-
-
-
-// Vertex/Normal/Color, etc: the address of the function pointer
-// is known at codegen time.
-
-
-// Unfortunately, have to play with the stack in the non-fv case:
-// 
-GLOBL( _tnl_x86_dispatch_attrf )
-	subl	$12, %esp	# gcc does 16 byte alignment of stack frames?
-	leal	16(%esp), %edx	# address of first float on stack
-	movl	%edx, (%esp)	# save as 'v'
-	call	*SUBST(0)	# 0x0 --> tabfv[attr][n]
-	addl	$12, %esp	# tear down frame
-	ret			# return
-GLOBL( _tnl_x86_dispatch_attrf_end )
-
-// The fv case is simpler:
-// 
+/* Unfortunately, have to play with the stack in the non-fv case:
+ */
+#if !defined (STDCALL_API)
+GLOBL( _tnl_x86_dispatch_attrf1 )
+GLOBL( _tnl_x86_dispatch_attrf2 )
+GLOBL( _tnl_x86_dispatch_attrf3 )
+GLOBL( _tnl_x86_dispatch_attrf4 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	leal	16(%esp), %edx	/* address of first float on stack */
+	movl	%edx, (%esp)	/* save as 'v' */
+	call	*SUBST(0)	/* 0x0 --> tabfv[attr][n] */
+	addl	$12, %esp	/* tear down frame */
+	ret			/* return */
+GLOBL( _tnl_x86_dispatch_attrf4_end )
+GLOBL( _tnl_x86_dispatch_attrf3_end )
+GLOBL( _tnl_x86_dispatch_attrf2_end )
+GLOBL( _tnl_x86_dispatch_attrf1_end )
+
+#else  /* defined(STDCALL_API) */
+
+GLOBL( _tnl_x86_dispatch_attrf1 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	leal	16(%esp), %edx	/* address of first float on stack */
+	movl	%edx, (%esp)	/* save as 'v' */
+	call	*SUBST(0)	/* 0x0 --> tabfv[attr][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$4		/* return */
+GLOBL( _tnl_x86_dispatch_attrf1_end )
+
+GLOBL( _tnl_x86_dispatch_attrf2 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	leal	16(%esp), %edx	/* address of first float on stack */
+	movl	%edx, (%esp)	/* save as 'v' */
+	call	*SUBST(0)	/* 0x0 --> tabfv[attr][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$8		/* return */
+GLOBL( _tnl_x86_dispatch_attrf2_end )
+
+GLOBL( _tnl_x86_dispatch_attrf3 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	leal	16(%esp), %edx	/* address of first float on stack */
+	movl	%edx, (%esp)	/* save as 'v' */
+	call	*SUBST(0)	/* 0x0 --> tabfv[attr][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$12		/* return */
+GLOBL( _tnl_x86_dispatch_attrf3_end )
+
+GLOBL( _tnl_x86_dispatch_attrf4 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	leal	16(%esp), %edx	/* address of first float on stack */
+	movl	%edx, (%esp)	/* save as 'v' */
+	call	*SUBST(0)	/* 0x0 --> tabfv[attr][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$16		/* return */
+GLOBL( _tnl_x86_dispatch_attrf4_end )
+#endif /* defined(STDCALL_API) */
+
+/* The fv case is simpler:
+ */
 GLOBL( _tnl_x86_dispatch_attrfv )
-	jmp	*SUBST(0)	# 0x0 --> tabfv[attr][n]
+	jmp	*SUBST(0)	/* 0x0 --> tabfv[attr][n] */
 GLOBL( _tnl_x86_dispatch_attrfv_end )
 
 
-// MultiTexcoord: the address of the function pointer must be
-// calculated, but can use the index argument slot to hold 'v', and
-// avoid setting up a new stack frame.
-//
-// [dBorca]
-// right, this would be the preferred approach, but gcc does not
-// clean up the stack after each function call when optimizing (-fdefer-pop);
-// can it make assumptions about what is already on the stack?  I dunno,
-// but in this case, we can't mess with the caller's stack frame, and
-// we must use a model like '_x86_dispatch_attrfv' above.  Caveat emptor!
-
-// Also, will only need a maximum of four of each of these per context:
-// 
-GLOBL( _tnl_x86_dispatch_multitexcoordf )
+/* MultiTexcoord: the address of the function pointer must be
+ * calculated, but can use the index argument slot to hold 'v', and
+ * avoid setting up a new stack frame.
+ *
+ * [dBorca]
+ * right, this would be the preferred approach, but gcc does not
+ * clean up the stack after each function call when optimizing (-fdefer-pop);
+ * can it make assumptions about what's already on the stack?  I dunno,
+ * but in this case, we can't mess with the caller's stack frame, and
+ * we must use a model like `_x86_dispatch_attrfv' above.  Caveat emptor!
+ */
+
+/* Also, will only need a maximum of four of each of these per context:
+ */
+#if !defined (STDCALL_API)
+GLOBL( _tnl_x86_dispatch_multitexcoordf1 )
+GLOBL( _tnl_x86_dispatch_multitexcoordf2 )
+GLOBL( _tnl_x86_dispatch_multitexcoordf3 )
+GLOBL( _tnl_x86_dispatch_multitexcoordf4 )
 	movl	4(%esp), %ecx
 	leal	8(%esp), %edx
 	andl	$7, %ecx
 	movl	%edx, 4(%esp)
 	sall	$4, %ecx
-	jmp	*SUBST(0)(%ecx)	# 0x0 - tabfv[tex0][n]
-GLOBL( _tnl_x86_dispatch_multitexcoordf_end )
+	jmp	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
+GLOBL( _tnl_x86_dispatch_multitexcoordf4_end )
+GLOBL( _tnl_x86_dispatch_multitexcoordf3_end )
+GLOBL( _tnl_x86_dispatch_multitexcoordf2_end )
+GLOBL( _tnl_x86_dispatch_multitexcoordf1_end )
 
 GLOBL( _tnl_x86_dispatch_multitexcoordfv )
 	movl	4(%esp), %ecx
@@ -317,32 +377,181 @@ GLOBL( _tnl_x86_dispatch_multitexcoordfv )
 	andl	$7, %ecx
 	movl	%edx, 4(%esp)
 	sall	$4, %ecx
-	jmp	*SUBST(0)(%ecx)	# 0x0 - tabfv[tex0][n]
+	jmp	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
 GLOBL( _tnl_x86_dispatch_multitexcoordfv_end )
 
-// VertexAttrib: the address of the function pointer must be
-// calculated.
+#else  /* defined (STDCALL_API) */
+
+GLOBL( _tnl_x86_dispatch_multitexcoordf1 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %ecx
+	leal	20(%esp), %edx
+	andl	$7, %ecx
+	movl	%edx, (%esp)
+	sall	$4, %ecx
+	call	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$8		/* return */
+GLOBL( _tnl_x86_dispatch_multitexcoordf1_end )
+
+GLOBL( _tnl_x86_dispatch_multitexcoordf2 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %ecx
+	leal	20(%esp), %edx
+	andl	$7, %ecx
+	movl	%edx, (%esp)
+	sall	$4, %ecx
+	call	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$12		/* return */
+GLOBL( _tnl_x86_dispatch_multitexcoordf2_end )
+
+GLOBL( _tnl_x86_dispatch_multitexcoordf3 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %ecx
+	leal	20(%esp), %edx
+	andl	$7, %ecx
+	movl	%edx, (%esp)
+	sall	$4, %ecx
+	call	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$16		/* return */
+GLOBL( _tnl_x86_dispatch_multitexcoordf3_end )
+
+GLOBL( _tnl_x86_dispatch_multitexcoordf4 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %ecx
+	leal	20(%esp), %edx
+	andl	$7, %ecx
+	movl	%edx, (%esp)
+	sall	$4, %ecx
+	call	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$20		/* return */
+GLOBL( _tnl_x86_dispatch_multitexcoordf4_end )
 
-GLOBL( _tnl_x86_dispatch_vertexattribf )
+GLOBL( _tnl_x86_dispatch_multitexcoordfv )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %ecx
+	movl	20(%esp), %edx
+	andl	$7, %ecx
+	movl	%edx, (%esp)
+	sall	$4, %ecx
+	call	*SUBST(0)(%ecx)	/* 0x0 - tabfv[tex0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$8		/* return */
+GLOBL( _tnl_x86_dispatch_multitexcoordfv_end )
+#endif /* defined (STDCALL_API) */
+
+
+/* VertexAttrib: the address of the function pointer must be
+ * calculated.
+ */
+#if !defined (STDCALL_API)
+GLOBL( _tnl_x86_dispatch_vertexattribf1 )
+GLOBL( _tnl_x86_dispatch_vertexattribf2 )
+GLOBL( _tnl_x86_dispatch_vertexattribf3 )
+GLOBL( _tnl_x86_dispatch_vertexattribf4 )
 	movl	4(%esp), %eax
 	cmpl	$16, %eax
-	jb	.8		# "cmovge" is not supported on all CPUs
+	jb	.8		/* "cmovge" is not supported on all CPUs */
 	movl	$16, %eax
 .8:
-	leal	8(%esp), %ecx	# calculate 'v'
-	movl	%ecx, 4(%esp)	# save in 1st arg slot
+	leal	8(%esp), %ecx	/* calculate 'v' */
+	movl	%ecx, 4(%esp)	/* save in 1st arg slot */
 	sall	$4, %eax
-	jmp	*SUBST(0)(%eax)	# 0x0 - tabfv[0][n]
-GLOBL( _tnl_x86_dispatch_vertexattribf_end )
+	jmp	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+GLOBL( _tnl_x86_dispatch_vertexattribf4_end )
+GLOBL( _tnl_x86_dispatch_vertexattribf3_end )
+GLOBL( _tnl_x86_dispatch_vertexattribf2_end )
+GLOBL( _tnl_x86_dispatch_vertexattribf1_end )
 
 GLOBL( _tnl_x86_dispatch_vertexattribfv )
 	movl	4(%esp), %eax
 	cmpl	$16, %eax
-	jb	.9		# "cmovge" is not supported on all CPUs
+	jb	.9		/* "cmovge" is not supported on all CPUs */
+	movl	$16, %eax
+.9:
+	movl	8(%esp), %ecx	/* load 'v' */
+	movl	%ecx, 4(%esp)	/* save in 1st arg slot */
+	sall	$4, %eax
+	jmp	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+GLOBL( _tnl_x86_dispatch_vertexattribfv_end )
+
+#else  /* defined (STDCALL_API) */
+
+GLOBL( _tnl_x86_dispatch_vertexattribf1 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %eax
+	cmpl	$16, %eax
+	jb	.81		/* "cmovge" is not supported on all CPUs */
+	movl	$16, %eax
+.81:
+	leal	20(%esp), %ecx	/* load 'v' */
+	movl	%ecx, (%esp)	/* save in 1st arg slot */
+	sall	$4, %eax
+	call	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$8		/* return */
+GLOBL( _tnl_x86_dispatch_vertexattribf1_end )
+
+GLOBL( _tnl_x86_dispatch_vertexattribf2 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %eax
+	cmpl	$16, %eax
+	jb	.82		/* "cmovge" is not supported on all CPUs */
+	movl	$16, %eax
+.82:
+	leal	20(%esp), %ecx	/* load 'v' */
+	movl	%ecx, (%esp)	/* save in 1st arg slot */
+	sall	$4, %eax
+	call	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$12		/* return */
+GLOBL( _tnl_x86_dispatch_vertexattribf2_end )
+
+GLOBL( _tnl_x86_dispatch_vertexattribf3 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %eax
+	cmpl	$16, %eax
+	jb	.83		/* "cmovge" is not supported on all CPUs */
+	movl	$16, %eax
+.83:
+	leal	20(%esp), %ecx	/* load 'v' */
+	movl	%ecx, (%esp)	/* save in 1st arg slot */
+	sall	$4, %eax
+	call	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$16		/* return */
+GLOBL( _tnl_x86_dispatch_vertexattribf3_end )
+
+GLOBL( _tnl_x86_dispatch_vertexattribf4 )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %eax
+	cmpl	$16, %eax
+	jb	.84		/* "cmovge" is not supported on all CPUs */
+	movl	$16, %eax
+.84:
+	leal	20(%esp), %ecx	/* load 'v' */
+	movl	%ecx, (%esp)	/* save in 1st arg slot */
+	sall	$4, %eax
+	call	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$20		/* return */
+GLOBL( _tnl_x86_dispatch_vertexattribf4_end )
+
+GLOBL( _tnl_x86_dispatch_vertexattribfv )
+	subl	$12, %esp	/* gcc does 16 byte alignment of stack frames? */
+	movl	16(%esp), %eax
+	cmpl	$16, %eax
+	jb	.9		/* "cmovge" is not supported on all CPUs */
 	movl	$16, %eax
 .9:
-	movl	8(%esp), %ecx	# load 'v'
-	movl	%ecx, 4(%esp)	# save in 1st arg slot
+	movl	20(%esp), %ecx	/* load 'v' */
+	movl	%ecx, (%esp)	/* save in 1st arg slot */
 	sall	$4, %eax
-	jmp	*SUBST(0)(%eax)	# 0x0 - tabfv[0][n]
+	call	*SUBST(0)(%eax)	/* 0x0 - tabfv[0][n] */
+	addl	$8, %esp	/* tear down frame (4 shaved off by the callee) */
+	ret	$8		/* return */
 GLOBL( _tnl_x86_dispatch_vertexattribfv_end )
+#endif /* defined (STDCALL_API) */
diff --git a/src/mesa/x86/assyntax.h b/src/mesa/x86/assyntax.h
index c048790c43..62d079f253 100644
--- a/src/mesa/x86/assyntax.h
+++ b/src/mesa/x86/assyntax.h
@@ -1300,11 +1300,11 @@ SECTION _DATA public align=16 class=DATA use32 flat
 #define REPZ			REPE
 #define RET			ret
 #define SAHF			sahf
-#define SAL_L(a, b)		sal L_(b), L_(a)
-#define SAL_W(a, b)		sal W_(b), W_(a)
+#define SAL_L(a, b)		sal L_(b), B_(a)
+#define SAL_W(a, b)		sal W_(b), B_(a)
 #define SAL_B(a, b)		sal B_(b), B_(a)
-#define SAR_L(a, b)		sar L_(b), L_(a)
-#define SAR_W(a, b)		sar W_(b), W_(a)
+#define SAR_L(a, b)		sar L_(b), B_(a)
+#define SAR_W(a, b)		sar W_(b), B_(a)
 #define SAR_B(a, b)		sar B_(b), B_(a)
 #define SBB_L(a, b)		sbb L_(b), L_(a)
 #define SBB_W(a, b)		sbb W_(b), W_(a)