Return to d_copy.s CVS log

Up to [Quake] / quake1

Annotation of quake1/d_copy.s, revision 1.1

1.1     ! root        1: //
        !             2: // d_copy.s
        !             3: // x86 assembly-language screen copying code.
        !             4: //
        !             5: 
        !             6: #include "asm_i386.h"
        !             7: #include "quakeasm.h"
        !             8: #include "asm_draw.h"
        !             9: 
        !            10:        .data
        !            11: 
        !            12: LCopyWidth:            .long   0
        !            13: LBlockSrcStep: .long   0
        !            14: LBlockDestStep:        .long   0
        !            15: LSrcDelta:             .long   0
        !            16: LDestDelta:            .long   0
        !            17: 
        !            18: #define bufptr 4+16
        !            19: 
        !            20: // copies 16 rows per plane at a pop; idea is that 16*512 = 8k, and since
        !            21: // no Mode X mode is wider than 360, all the data should fit in the cache for
        !            22: // the passes for the next 3 planes
        !            23: 
        !            24:        .text
        !            25: 
        !            26: .globl C(VGA_UpdatePlanarScreen)
        !            27: C(VGA_UpdatePlanarScreen):
        !            28:        pushl   %ebp                            // preserve caller's stack frame
        !            29:        pushl   %edi
        !            30:        pushl   %esi                            // preserve register variables
        !            31:        pushl   %ebx
        !            32: 
        !            33:        movl    C(VGA_bufferrowbytes),%eax
        !            34:        shll    $1,%eax
        !            35:        movl    %eax,LBlockSrcStep
        !            36:        movl    C(VGA_rowbytes),%eax
        !            37:        shll    $1,%eax
        !            38:        movl    %eax,LBlockDestStep
        !            39: 
        !            40:        movl    $0x3C4,%edx
        !            41:        movl    $2,%al
        !            42:        outb    %al,%dx         // point the SC to the Map Mask
        !            43:        incl    %edx
        !            44: 
        !            45:        movl    bufptr(%esp),%esi
        !            46:        movl    C(VGA_pagebase),%edi
        !            47:        movl    C(VGA_height),%ebp
        !            48:        shrl    $1,%ebp
        !            49: 
        !            50:        movl    C(VGA_width),%ecx
        !            51:        movl    C(VGA_bufferrowbytes),%eax
        !            52:        subl    %ecx,%eax
        !            53:        movl    %eax,LSrcDelta
        !            54:        movl    C(VGA_rowbytes),%eax
        !            55:        shll    $2,%eax
        !            56:        subl    %ecx,%eax
        !            57:        movl    %eax,LDestDelta
        !            58:        shrl    $4,%ecx
        !            59:        movl    %ecx,LCopyWidth
        !            60: 
        !            61: LRowLoop:
        !            62:        movb    $1,%al
        !            63: 
        !            64: LPlaneLoop:
        !            65:        outb    %al,%dx
        !            66:        movb    $2,%ah
        !            67: 
        !            68:        pushl   %esi
        !            69:        pushl   %edi
        !            70: LRowSetLoop:
        !            71:        movl    LCopyWidth,%ecx
        !            72: LColumnLoop:
        !            73:        movb    12(%esi),%bh
        !            74:        movb    8(%esi),%bl
        !            75:        shll    $16,%ebx
        !            76:        movb    4(%esi),%bh
        !            77:        movb    (%esi),%bl
        !            78:        movl    %ebx,(%edi)
        !            79:        addl    $16,%esi
        !            80:        addl    $4,%edi
        !            81:        decl    %ecx
        !            82:        jnz             LColumnLoop
        !            83: 
        !            84:        addl    LDestDelta,%edi
        !            85:        addl    LSrcDelta,%esi
        !            86:        decb    %ah
        !            87:        jnz             LRowSetLoop
        !            88: 
        !            89:        popl    %edi
        !            90:        popl    %esi
        !            91:        incl    %esi
        !            92: 
        !            93:        shlb    $1,%al
        !            94:        cmpb    $16,%al
        !            95:        jnz             LPlaneLoop
        !            96: 
        !            97:        subl    $4,%esi
        !            98:        addl    LBlockSrcStep,%esi
        !            99:        addl    LBlockDestStep,%edi
        !           100:        decl    %ebp
        !           101:        jnz             LRowLoop
        !           102: 
        !           103:        popl    %ebx                            // restore register variables
        !           104:        popl    %esi
        !           105:        popl    %edi
        !           106:        popl    %ebp                            // restore the caller's stack frame
        !           107: 
        !           108:        ret
        !           109: 
        !           110: 
        !           111: #define srcptr                 4+16
        !           112: #define destptr                        8+16
        !           113: #define width                  12+16
        !           114: #define height                 16+16
        !           115: #define srcrowbytes            20+16
        !           116: #define destrowbytes   24+16
        !           117: 
        !           118: .globl C(VGA_UpdateLinearScreen)
        !           119: C(VGA_UpdateLinearScreen):
        !           120:        pushl   %ebp                            // preserve caller's stack frame
        !           121:        pushl   %edi
        !           122:        pushl   %esi                            // preserve register variables
        !           123:        pushl   %ebx
        !           124: 
        !           125:        cld
        !           126:        movl    srcptr(%esp),%esi
        !           127:        movl    destptr(%esp),%edi
        !           128:        movl    width(%esp),%ebx
        !           129:        movl    srcrowbytes(%esp),%eax
        !           130:        subl    %ebx,%eax
        !           131:        movl    destrowbytes(%esp),%edx
        !           132:        subl    %ebx,%edx
        !           133:        shrl    $2,%ebx
        !           134:        movl    height(%esp),%ebp
        !           135: LLRowLoop:
        !           136:        movl    %ebx,%ecx
        !           137:        rep/movsl       (%esi),(%edi)
        !           138:        addl    %eax,%esi
        !           139:        addl    %edx,%edi
        !           140:        decl    %ebp
        !           141:        jnz             LLRowLoop
        !           142: 
        !           143:        popl    %ebx                            // restore register variables
        !           144:        popl    %esi
        !           145:        popl    %edi
        !           146:        popl    %ebp                            // restore the caller's stack frame
        !           147: 
        !           148:        ret
        !           149: 

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