Return to worlda.s CVS log

Up to [Quake] / quake1

Annotation of quake1/worlda.s, revision 1.1

1.1     ! root        1: //
        !             2: // worlda.s
        !             3: // x86 assembly-language server testing stuff
        !             4: //
        !             5: 
        !             6: #include "asm_i386.h"
        !             7: #include "quakeasm.h"
        !             8: #include "d_ifacea.h"
        !             9: 
        !            10: #if id386
        !            11: 
        !            12:        .data
        !            13: 
        !            14: Ltemp: .long   0
        !            15: 
        !            16:        .text
        !            17: 
        !            18: //----------------------------------------------------------------------
        !            19: // hull-point test
        !            20: //----------------------------------------------------------------------
        !            21: 
        !            22: #define hull   4+8                             // because only partially pushed
        !            23: #define        num             8+4                             // because only partially pushed
        !            24: #define p              12+12                   // because only partially pushed
        !            25: 
        !            26:        .align 4
        !            27: .globl C(SV_HullPointContents)
        !            28: C(SV_HullPointContents):
        !            29:        pushl   %edi                            // preserve register variables
        !            30:        movl    num(%esp),%eax
        !            31:        testl   %eax,%eax
        !            32:        js              Lhquickout
        !            33: 
        !            34: //     float           d;
        !            35: //     dclipnode_t     *node;
        !            36: //     mplane_t        *plane;
        !            37: 
        !            38:        pushl   %ebx
        !            39:        movl    hull(%esp),%ebx
        !            40: 
        !            41:        pushl   %ebp
        !            42:        movl    p(%esp),%edx
        !            43: 
        !            44:        movl    hu_clipnodes(%ebx),%edi
        !            45:        movl    hu_planes(%ebx),%ebp
        !            46: 
        !            47:        subl    %ebx,%ebx
        !            48:        pushl   %esi
        !            49: 
        !            50: // %ebx: 0
        !            51: // %eax: num
        !            52: // %edx: p
        !            53: // %edi: hull->clipnodes
        !            54: // %ebp: hull->planes
        !            55: 
        !            56: //     while (num >= 0)
        !            57: //     {
        !            58: 
        !            59: Lhloop:
        !            60: 
        !            61: //             node = hull->clipnodes + num;
        !            62: //             plane = hull->planes + node->planenum;
        !            63: // !!! if the size of dclipnode_t changes, the scaling of %eax needs to be
        !            64: //     changed !!!
        !            65:        movl    nd_planenum(%edi,%eax,8),%ecx
        !            66:        movl    nd_children(%edi,%eax,8),%eax
        !            67:        movl    %eax,%esi
        !            68:        rorl    $16,%eax
        !            69:        leal    (%ecx,%ecx,4),%ecx
        !            70: 
        !            71: //             if (plane->type < 3)
        !            72: //                     d = p[plane->type] - plane->dist;
        !            73:        movb    pl_type(%ebp,%ecx,4),%bl
        !            74:        cmpb    $3,%bl
        !            75:        jb              Lnodot
        !            76: 
        !            77: //             else
        !            78: //                     d = DotProduct (plane->normal, p) - plane->dist;
        !            79:        flds    pl_normal(%ebp,%ecx,4)
        !            80:        fmuls   0(%edx)
        !            81:        flds    pl_normal+4(%ebp,%ecx,4)
        !            82:        fmuls   4(%edx)
        !            83:        flds    pl_normal+8(%ebp,%ecx,4)
        !            84:        fmuls   8(%edx)
        !            85:        fxch    %st(1)
        !            86:        faddp   %st(0),%st(2)
        !            87:        faddp   %st(0),%st(1)
        !            88:        fsubs   pl_dist(%ebp,%ecx,4)
        !            89:        jmp             Lsub
        !            90: 
        !            91: Lnodot:
        !            92:        flds    pl_dist(%ebp,%ecx,4)
        !            93:        fsubrs  (%edx,%ebx,4)
        !            94: 
        !            95: Lsub:
        !            96:        sarl    $16,%eax
        !            97:        sarl    $16,%esi
        !            98: 
        !            99: //             if (d < 0)
        !           100: //                     num = node->children[1];
        !           101: //             else
        !           102: //                     num = node->children[0];
        !           103:        fstps   Ltemp
        !           104:        movl    Ltemp,%ecx
        !           105:        sarl    $31,%ecx
        !           106:        andl    %ecx,%esi
        !           107:        xorl    $0xFFFFFFFF,%ecx
        !           108:        andl    %ecx,%eax
        !           109:        orl             %esi,%eax
        !           110:        jns             Lhloop
        !           111: 
        !           112: //     return num;
        !           113: Lhdone:
        !           114:        popl    %esi
        !           115:        popl    %ebp
        !           116:        popl    %ebx                            // restore register variables
        !           117: 
        !           118: Lhquickout:
        !           119:        popl    %edi
        !           120: 
        !           121:        ret
        !           122: 
        !           123: #endif // id386
        !           124: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.