summaryrefslogtreecommitdiffstats
path: root/src/mesa
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa')
-rw-r--r--src/mesa/Makefile.mgw7
-rw-r--r--src/mesa/tnl/t_vtx_api.c16
-rw-r--r--src/mesa/tnl/t_vtx_api.h2
-rw-r--r--src/mesa/tnl/t_vtx_x86.c156
-rw-r--r--src/mesa/tnl/t_vtx_x86_gcc.S573
-rw-r--r--src/mesa/x86/assyntax.h8
6 files changed, 474 insertions, 288 deletions
diff --git a/src/mesa/Makefile.mgw b/src/mesa/Makefile.mgw
index 9084bf478ba..a209e582d9b 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 0e28c73910a..24ced9da181 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 f58461332ec..97d5cf55638 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 5aafedebbe6..5d7f95e98b7 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 bad87d3ee9e..fcc69f1d0d1 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 <[email protected]>
+ * Daniel Borca <[email protected]>
*/
-#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 c048790c431..62d079f2533 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)
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-21 06:31:56 +0000