Subversion Repositories Kolibri OS

/*

Copyright (C) 1996-1997 Id Software, Inc.

 

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

 

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

 

See the GNU General Public License for more details.

 

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 

*/

//

// r_edgea.s

// x86 assembly-language edge-processing code.

//

 

#include "asm_i386.h"

#include "quakeasm.h"

#include "asm_draw.h"

 

#if     id386

 

        .data

Ltemp:                                  .long   0

float_1_div_0100000h:   .long   0x35800000      // 1.0/(float)0x100000

float_point_999:                .single 0.999

float_1_point_001:              .single 1.001

 

        .text

 

//--------------------------------------------------------------------

 

#define edgestoadd      4+8             // note odd stack offsets because of interleaving

#define edgelist        8+12    // with pushes

 

.globl C(R_EdgeCodeStart)

C(R_EdgeCodeStart):

 

.globl C(R_InsertNewEdges)

C(R_InsertNewEdges):

        pushl   %edi

        pushl   %esi                            // preserve register variables

        movl    edgestoadd(%esp),%edx

        pushl   %ebx

        movl    edgelist(%esp),%ecx

 

LDoNextEdge:

        movl    et_u(%edx),%eax

        movl    %edx,%edi

 

LContinueSearch:

        movl    et_u(%ecx),%ebx

        movl    et_next(%ecx),%esi

        cmpl    %ebx,%eax

        jle             LAddedge

        movl    et_u(%esi),%ebx

        movl    et_next(%esi),%ecx

        cmpl    %ebx,%eax

        jle             LAddedge2

        movl    et_u(%ecx),%ebx

        movl    et_next(%ecx),%esi

        cmpl    %ebx,%eax

        jle             LAddedge

        movl    et_u(%esi),%ebx

        movl    et_next(%esi),%ecx

        cmpl    %ebx,%eax

        jg              LContinueSearch

 

LAddedge2:

        movl    et_next(%edx),%edx

        movl    et_prev(%esi),%ebx

        movl    %esi,et_next(%edi)

        movl    %ebx,et_prev(%edi)

        movl    %edi,et_next(%ebx)

        movl    %edi,et_prev(%esi)

        movl    %esi,%ecx

 

        cmpl    $0,%edx

        jnz             LDoNextEdge

        jmp             LDone

 

        .align 4

LAddedge:

        movl    et_next(%edx),%edx

        movl    et_prev(%ecx),%ebx

        movl    %ecx,et_next(%edi)

        movl    %ebx,et_prev(%edi)

        movl    %edi,et_next(%ebx)

        movl    %edi,et_prev(%ecx)

 

        cmpl    $0,%edx

        jnz             LDoNextEdge

 

LDone:

        popl    %ebx                            // restore register variables

        popl    %esi

        popl    %edi

 

        ret

 

//--------------------------------------------------------------------

 

#define predge  4+4

 

.globl C(R_RemoveEdges)

C(R_RemoveEdges):

        pushl   %ebx

        movl    predge(%esp),%eax

 

Lre_loop:

        movl    et_next(%eax),%ecx

        movl    et_nextremove(%eax),%ebx

        movl    et_prev(%eax),%edx

        testl   %ebx,%ebx

        movl    %edx,et_prev(%ecx)

        jz              Lre_done

        movl    %ecx,et_next(%edx)

 

        movl    et_next(%ebx),%ecx

        movl    et_prev(%ebx),%edx

        movl    et_nextremove(%ebx),%eax

        movl    %edx,et_prev(%ecx)

        testl   %eax,%eax

        movl    %ecx,et_next(%edx)

        jnz             Lre_loop

 

        popl    %ebx

        ret

 

Lre_done:

        movl    %ecx,et_next(%edx)

        popl    %ebx

 

        ret

 

//--------------------------------------------------------------------

 

#define pedgelist       4+4             // note odd stack offset because of interleaving

                                                        // with pushes

 

.globl C(R_StepActiveU)

C(R_StepActiveU):

        pushl   %edi

        movl    pedgelist(%esp),%edx

        pushl   %esi                            // preserve register variables

        pushl   %ebx

 

        movl    et_prev(%edx),%esi

 

LNewEdge:

        movl    et_u(%esi),%edi

 

LNextEdge:

        movl    et_u(%edx),%eax

        movl    et_u_step(%edx),%ebx

        addl    %ebx,%eax

        movl    et_next(%edx),%esi

        movl    %eax,et_u(%edx)

        cmpl    %edi,%eax

        jl              LPushBack

 

        movl    et_u(%esi),%edi

        movl    et_u_step(%esi),%ebx

        addl    %ebx,%edi

        movl    et_next(%esi),%edx

        movl    %edi,et_u(%esi)

        cmpl    %eax,%edi

        jl              LPushBack2

 

        movl    et_u(%edx),%eax

        movl    et_u_step(%edx),%ebx

        addl    %ebx,%eax

        movl    et_next(%edx),%esi

        movl    %eax,et_u(%edx)

        cmpl    %edi,%eax

        jl              LPushBack

 

        movl    et_u(%esi),%edi

        movl    et_u_step(%esi),%ebx

        addl    %ebx,%edi

        movl    et_next(%esi),%edx

        movl    %edi,et_u(%esi)

        cmpl    %eax,%edi

        jnl             LNextEdge

 

LPushBack2:

        movl    %edx,%ebx

        movl    %edi,%eax

        movl    %esi,%edx

        movl    %ebx,%esi

 

LPushBack:

// push it back to keep it sorted

        movl    et_prev(%edx),%ecx

        movl    et_next(%edx),%ebx

 

// done if the -1 in edge_aftertail triggered this

        cmpl    $(C(edge_aftertail)),%edx

        jz              LUDone

 

// pull the edge out of the edge list

        movl    et_prev(%ecx),%edi

        movl    %ecx,et_prev(%esi)

        movl    %ebx,et_next(%ecx)

 

// find out where the edge goes in the edge list

LPushBackLoop:

        movl    et_prev(%edi),%ecx

        movl    et_u(%edi),%ebx

        cmpl    %ebx,%eax

        jnl             LPushBackFound

 

        movl    et_prev(%ecx),%edi

        movl    et_u(%ecx),%ebx

        cmpl    %ebx,%eax

        jl              LPushBackLoop

 

        movl    %ecx,%edi

 

// put the edge back into the edge list

LPushBackFound:

        movl    et_next(%edi),%ebx

        movl    %edi,et_prev(%edx)

        movl    %ebx,et_next(%edx)

        movl    %edx,et_next(%edi)

        movl    %edx,et_prev(%ebx)

 

        movl    %esi,%edx

        movl    et_prev(%esi),%esi

 

        cmpl    $(C(edge_tail)),%edx

        jnz             LNewEdge

 

LUDone:

        popl    %ebx                            // restore register variables

        popl    %esi

        popl    %edi

 

        ret

 

//--------------------------------------------------------------------

 

#define surf    4               // note this is loaded before any pushes

 

        .align 4

TrailingEdge:

        movl    st_spanstate(%esi),%eax // check for edge inversion

        decl    %eax

        jnz             LInverted

 

        movl    %eax,st_spanstate(%esi)

        movl    st_insubmodel(%esi),%ecx

        movl    0x12345678,%edx         // surfaces[1].st_next

LPatch0:

        movl    C(r_bmodelactive),%eax

        subl    %ecx,%eax

        cmpl    %esi,%edx

        movl    %eax,C(r_bmodelactive)

        jnz             LNoEmit                         // surface isn't on top, just remove

 

// emit a span (current top going away)

        movl    et_u(%ebx),%eax

        shrl    $20,%eax                                // iu = integral pixel u

        movl    st_last_u(%esi),%edx

        movl    st_next(%esi),%ecx

        cmpl    %edx,%eax

        jle             LNoEmit2                                // iu <= surf->last_u, so nothing to emit

 

        movl    %eax,st_last_u(%ecx)    // surf->next->last_u = iu;

        subl    %edx,%eax

        movl    %edx,espan_t_u(%ebp)            // span->u = surf->last_u;

 

        movl    %eax,espan_t_count(%ebp)        // span->count = iu - span->u;

        movl    C(current_iv),%eax

        movl    %eax,espan_t_v(%ebp)            // span->v = current_iv;

        movl    st_spans(%esi),%eax

        movl    %eax,espan_t_pnext(%ebp)        // span->pnext = surf->spans;

        movl    %ebp,st_spans(%esi)                     // surf->spans = span;

        addl    $(espan_t_size),%ebp

 

        movl    st_next(%esi),%edx              // remove the surface from the surface

        movl    st_prev(%esi),%esi              // stack

 

        movl    %edx,st_next(%esi)

        movl    %esi,st_prev(%edx)

        ret

 

LNoEmit2:

        movl    %eax,st_last_u(%ecx)    // surf->next->last_u = iu;

        movl    st_next(%esi),%edx              // remove the surface from the surface

        movl    st_prev(%esi),%esi              // stack

 

        movl    %edx,st_next(%esi)

        movl    %esi,st_prev(%edx)

        ret

 

LNoEmit:

        movl    st_next(%esi),%edx              // remove the surface from the surface

        movl    st_prev(%esi),%esi              // stack

 

        movl    %edx,st_next(%esi)

        movl    %esi,st_prev(%edx)

        ret

 

LInverted:

        movl    %eax,st_spanstate(%esi)

        ret

 

//--------------------------------------------------------------------

 

// trailing edge only

Lgs_trailing:

        pushl   $Lgs_nextedge

        jmp             TrailingEdge

 

 

.globl C(R_GenerateSpans)

C(R_GenerateSpans):

        pushl   %ebp                            // preserve caller's stack frame

        pushl   %edi

        pushl   %esi                            // preserve register variables

        pushl   %ebx

 

// clear active surfaces to just the background surface

        movl    C(surfaces),%eax

        movl    C(edge_head_u_shift20),%edx

        addl    $(st_size),%eax

// %ebp = span_p throughout

        movl    C(span_p),%ebp

 

        movl    $0,C(r_bmodelactive)

 

        movl    %eax,st_next(%eax)

        movl    %eax,st_prev(%eax)

        movl    %edx,st_last_u(%eax)

        movl    C(edge_head)+et_next,%ebx               // edge=edge_head.next

 

// generate spans

        cmpl    $(C(edge_tail)),%ebx            // done if empty list

        jz              Lgs_lastspan

 

Lgs_edgeloop:

 

        movl    et_surfs(%ebx),%edi

        movl    C(surfaces),%eax

        movl    %edi,%esi

        andl    $0xFFFF0000,%edi

        andl    $0xFFFF,%esi

        jz              Lgs_leading             // not a trailing edge

 

// it has a left surface, so a surface is going away for this span

        shll    $(SURF_T_SHIFT),%esi

        addl    %eax,%esi

        testl   %edi,%edi

        jz              Lgs_trailing

 

// both leading and trailing

        call    TrailingEdge

        movl    C(surfaces),%eax

 

// ---------------------------------------------------------------

// handle a leading edge

// ---------------------------------------------------------------

 

Lgs_leading:

        shrl    $16-SURF_T_SHIFT,%edi

        movl    C(surfaces),%eax

        addl    %eax,%edi

        movl    0x12345678,%esi         // surf2 = surfaces[1].next;

LPatch2:

        movl    st_spanstate(%edi),%edx

        movl    st_insubmodel(%edi),%eax

        testl   %eax,%eax

        jnz             Lbmodel_leading

 

// handle a leading non-bmodel edge

 

// don't start a span if this is an inverted span, with the end edge preceding

// the start edge (that is, we've already seen the end edge)

        testl   %edx,%edx

        jnz             Lxl_done

 

 

// if (surf->key < surf2->key)

//              goto newtop;

        incl    %edx

        movl    st_key(%edi),%eax

        movl    %edx,st_spanstate(%edi)

        movl    st_key(%esi),%ecx

        cmpl    %ecx,%eax

        jl              Lnewtop

 

// main sorting loop to search through surface stack until insertion point

// found. Always terminates because background surface is sentinel

// do

// {

//              surf2 = surf2->next;

// } while (surf->key >= surf2->key);

Lsortloopnb:

        movl    st_next(%esi),%esi

        movl    st_key(%esi),%ecx

        cmpl    %ecx,%eax

        jge             Lsortloopnb

 

        jmp             LInsertAndExit

 

 

// handle a leading bmodel edge

        .align  4

Lbmodel_leading:

 

// don't start a span if this is an inverted span, with the end edge preceding

// the start edge (that is, we've already seen the end edge)

        testl   %edx,%edx

        jnz             Lxl_done

 

        movl    C(r_bmodelactive),%ecx

        incl    %edx

        incl    %ecx

        movl    %edx,st_spanstate(%edi)

        movl    %ecx,C(r_bmodelactive)

 

// if (surf->key < surf2->key)

//              goto newtop;

        movl    st_key(%edi),%eax

        movl    st_key(%esi),%ecx

        cmpl    %ecx,%eax

        jl              Lnewtop

 

// if ((surf->key == surf2->key) && surf->insubmodel)

// {

        jz              Lzcheck_for_newtop

 

// main sorting loop to search through surface stack until insertion point

// found. Always terminates because background surface is sentinel

// do

// {

//              surf2 = surf2->next;

// } while (surf->key > surf2->key);

Lsortloop:

        movl    st_next(%esi),%esi

        movl    st_key(%esi),%ecx

        cmpl    %ecx,%eax

        jg              Lsortloop

 

        jne             LInsertAndExit

 

// Do 1/z sorting to see if we've arrived in the right position

        movl    et_u(%ebx),%eax

        subl    $0xFFFFF,%eax

        movl    %eax,Ltemp

        fildl   Ltemp

 

        fmuls   float_1_div_0100000h // fu = (float)(edge->u - 0xFFFFF) *

                                                                //      (1.0 / 0x100000);

 

        fld             %st(0)                          // fu | fu

        fmuls   st_d_zistepu(%edi)      // fu*surf->d_zistepu | fu

        flds    C(fv)                                   // fv | fu*surf->d_zistepu | fu

        fmuls   st_d_zistepv(%edi)      // fv*surf->d_zistepv | fu*surf->d_zistepu | fu

        fxch    %st(1)                          // fu*surf->d_zistepu | fv*surf->d_zistepv | fu

        fadds   st_d_ziorigin(%edi)     // fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fv*surf->d_zistepv | fu

 

        flds    st_d_zistepu(%esi)      // surf2->d_zistepu |

                                                                //  fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fv*surf->d_zistepv | fu

        fmul    %st(3),%st(0)           // fu*surf2->d_zistepu |

                                                                //  fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fv*surf->d_zistepv | fu

        fxch    %st(1)                          // fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fu*surf2->d_zistepu |

                                                                //  fv*surf->d_zistepv | fu

        faddp   %st(0),%st(2)           // fu*surf2->d_zistepu | newzi | fu

 

        flds    C(fv)                                   // fv | fu*surf2->d_zistepu | newzi | fu

        fmuls   st_d_zistepv(%esi)      // fv*surf2->d_zistepv |

                                                                //  fu*surf2->d_zistepu | newzi | fu

        fld             %st(2)                          // newzi | fv*surf2->d_zistepv |

                                                                //  fu*surf2->d_zistepu | newzi | fu

        fmuls   float_point_999         // newzibottom | fv*surf2->d_zistepv |

                                                                //  fu*surf2->d_zistepu | newzi | fu

 

        fxch    %st(2)                          // fu*surf2->d_zistepu | fv*surf2->d_zistepv |

                                                                //  newzibottom | newzi | fu

        fadds   st_d_ziorigin(%esi)     // fu*surf2->d_zistepu + surf2->d_ziorigin |

                                                                //  fv*surf2->d_zistepv | newzibottom | newzi |

                                                                //  fu

        faddp   %st(0),%st(1)           // testzi | newzibottom | newzi | fu

        fxch    %st(1)                          // newzibottom | testzi | newzi | fu

 

// if (newzibottom >= testzi)

//     goto Lgotposition;

 

        fcomp   %st(1)                          // testzi | newzi | fu

 

        fxch    %st(1)                          // newzi | testzi | fu

        fmuls   float_1_point_001       // newzitop | testzi | fu

        fxch    %st(1)                          // testzi | newzitop | fu

 

        fnstsw  %ax

        testb   $0x01,%ah

        jz              Lgotposition_fpop3

 

// if (newzitop >= testzi)

// {

 

        fcomp   %st(1)                          // newzitop | fu

        fnstsw  %ax

        testb   $0x45,%ah

        jz              Lsortloop_fpop2

 

// if (surf->d_zistepu >= surf2->d_zistepu)

//     goto newtop;

 

        flds    st_d_zistepu(%edi)      // surf->d_zistepu | newzitop| fu

        fcomps  st_d_zistepu(%esi)      // newzitop | fu

        fnstsw  %ax

        testb   $0x01,%ah

        jz              Lgotposition_fpop2

 

        fstp    %st(0)                          // clear the FPstack

        fstp    %st(0)

        movl    st_key(%edi),%eax

        jmp             Lsortloop

 

 

Lgotposition_fpop3:

        fstp    %st(0)

Lgotposition_fpop2:

        fstp    %st(0)

        fstp    %st(0)

        jmp             LInsertAndExit

 

 

// emit a span (obscures current top)

 

Lnewtop_fpop3:

        fstp    %st(0)

Lnewtop_fpop2:

        fstp    %st(0)

        fstp    %st(0)

        movl    st_key(%edi),%eax               // reload the sorting key

 

Lnewtop:

        movl    et_u(%ebx),%eax

        movl    st_last_u(%esi),%edx

        shrl    $20,%eax                                // iu = integral pixel u

        movl    %eax,st_last_u(%edi)    // surf->last_u = iu;

        cmpl    %edx,%eax

        jle             LInsertAndExit                  // iu <= surf->last_u, so nothing to emit

 

        subl    %edx,%eax

        movl    %edx,espan_t_u(%ebp)            // span->u = surf->last_u;

 

        movl    %eax,espan_t_count(%ebp)        // span->count = iu - span->u;

        movl    C(current_iv),%eax

        movl    %eax,espan_t_v(%ebp)            // span->v = current_iv;

        movl    st_spans(%esi),%eax

        movl    %eax,espan_t_pnext(%ebp)        // span->pnext = surf->spans;

        movl    %ebp,st_spans(%esi)                     // surf->spans = span;

        addl    $(espan_t_size),%ebp

 

LInsertAndExit:

// insert before surf2

        movl    %esi,st_next(%edi)              // surf->next = surf2;

        movl    st_prev(%esi),%eax

        movl    %eax,st_prev(%edi)              // surf->prev = surf2->prev;

        movl    %edi,st_prev(%esi)              // surf2->prev = surf;

        movl    %edi,st_next(%eax)              // surf2->prev->next = surf;

 

// ---------------------------------------------------------------

// leading edge done

// ---------------------------------------------------------------

 

// ---------------------------------------------------------------

// see if there are any more edges

// ---------------------------------------------------------------

 

Lgs_nextedge:

        movl    et_next(%ebx),%ebx

        cmpl    $(C(edge_tail)),%ebx

        jnz             Lgs_edgeloop

 

// clean up at the right edge

Lgs_lastspan:

 

// now that we've reached the right edge of the screen, we're done with any

// unfinished surfaces, so emit a span for whatever's on top

        movl    0x12345678,%esi         // surfaces[1].st_next

LPatch3:

        movl    C(edge_tail_u_shift20),%eax

        xorl    %ecx,%ecx

        movl    st_last_u(%esi),%edx

        subl    %edx,%eax

        jle             Lgs_resetspanstate

 

        movl    %edx,espan_t_u(%ebp)

        movl    %eax,espan_t_count(%ebp)

        movl    C(current_iv),%eax

        movl    %eax,espan_t_v(%ebp)

        movl    st_spans(%esi),%eax

        movl    %eax,espan_t_pnext(%ebp)

        movl    %ebp,st_spans(%esi)

        addl    $(espan_t_size),%ebp

 

// reset spanstate for all surfaces in the surface stack

Lgs_resetspanstate:

        movl    %ecx,st_spanstate(%esi)

        movl    st_next(%esi),%esi

        cmpl    $0x12345678,%esi                // &surfaces[1]

LPatch4:

        jnz             Lgs_resetspanstate

 

// store the final span_p

        movl    %ebp,C(span_p)

 

        popl    %ebx                            // restore register variables

        popl    %esi

        popl    %edi

        popl    %ebp                            // restore the caller's stack frame

        ret

 

 

// ---------------------------------------------------------------

// 1/z sorting for bmodels in the same leaf

// ---------------------------------------------------------------

        .align  4

Lxl_done:

        incl    %edx

        movl    %edx,st_spanstate(%edi)

 

        jmp             Lgs_nextedge

 

 

        .align  4

Lzcheck_for_newtop:

        movl    et_u(%ebx),%eax

        subl    $0xFFFFF,%eax

        movl    %eax,Ltemp

        fildl   Ltemp

 

        fmuls   float_1_div_0100000h // fu = (float)(edge->u - 0xFFFFF) *

                                                                //      (1.0 / 0x100000);

 

        fld             %st(0)                          // fu | fu

        fmuls   st_d_zistepu(%edi)      // fu*surf->d_zistepu | fu

        flds    C(fv)                           // fv | fu*surf->d_zistepu | fu

        fmuls   st_d_zistepv(%edi)      // fv*surf->d_zistepv | fu*surf->d_zistepu | fu

        fxch    %st(1)                          // fu*surf->d_zistepu | fv*surf->d_zistepv | fu

        fadds   st_d_ziorigin(%edi)     // fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fv*surf->d_zistepv | fu

 

        flds    st_d_zistepu(%esi)      // surf2->d_zistepu |

                                                                //  fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fv*surf->d_zistepv | fu

        fmul    %st(3),%st(0)           // fu*surf2->d_zistepu |

                                                                //  fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fv*surf->d_zistepv | fu

        fxch    %st(1)                          // fu*surf->d_zistepu + surf->d_ziorigin |

                                                                //  fu*surf2->d_zistepu |

                                                                //  fv*surf->d_zistepv | fu

        faddp   %st(0),%st(2)           // fu*surf2->d_zistepu | newzi | fu

 

        flds    C(fv)                           // fv | fu*surf2->d_zistepu | newzi | fu

        fmuls   st_d_zistepv(%esi)      // fv*surf2->d_zistepv |

                                                                //  fu*surf2->d_zistepu | newzi | fu

        fld             %st(2)                          // newzi | fv*surf2->d_zistepv |

                                                                //  fu*surf2->d_zistepu | newzi | fu

        fmuls   float_point_999         // newzibottom | fv*surf2->d_zistepv |

                                                                //  fu*surf2->d_zistepu | newzi | fu

 

        fxch    %st(2)                          // fu*surf2->d_zistepu | fv*surf2->d_zistepv |

                                                                //  newzibottom | newzi | fu

        fadds   st_d_ziorigin(%esi)     // fu*surf2->d_zistepu + surf2->d_ziorigin |

                                                                //  fv*surf2->d_zistepv | newzibottom | newzi |

                                                                //  fu

        faddp   %st(0),%st(1)           // testzi | newzibottom | newzi | fu

        fxch    %st(1)                          // newzibottom | testzi | newzi | fu

 

// if (newzibottom >= testzi)

//     goto newtop;

 

        fcomp   %st(1)                          // testzi | newzi | fu

 

        fxch    %st(1)                          // newzi | testzi | fu

        fmuls   float_1_point_001       // newzitop | testzi | fu

        fxch    %st(1)                          // testzi | newzitop | fu

 

        fnstsw  %ax

        testb   $0x01,%ah

        jz              Lnewtop_fpop3

 

// if (newzitop >= testzi)

// {

 

        fcomp   %st(1)                          // newzitop | fu

        fnstsw  %ax

        testb   $0x45,%ah

        jz              Lsortloop_fpop2

 

// if (surf->d_zistepu >= surf2->d_zistepu)

//     goto newtop;

 

        flds    st_d_zistepu(%edi)      // surf->d_zistepu | newzitop | fu

        fcomps  st_d_zistepu(%esi)      // newzitop | fu

        fnstsw  %ax

        testb   $0x01,%ah

        jz              Lnewtop_fpop2

 

Lsortloop_fpop2:

        fstp    %st(0)                          // clear the FP stack

        fstp    %st(0)

        movl    st_key(%edi),%eax

        jmp             Lsortloop

 

 

.globl C(R_EdgeCodeEnd)

C(R_EdgeCodeEnd):

 

 

//----------------------------------------------------------------------

// Surface array address code patching routine

//----------------------------------------------------------------------

 

        .align 4

.globl C(R_SurfacePatch)

C(R_SurfacePatch):

 

        movl    C(surfaces),%eax

        addl    $(st_size),%eax

        movl    %eax,LPatch4-4

 

        addl    $(st_next),%eax

        movl    %eax,LPatch0-4

        movl    %eax,LPatch2-4

        movl    %eax,LPatch3-4

 

        ret

 

#endif  // id386