Return to memory.s CVS log

Up to [MW Coherent from dump] / coherent / b / STREAMS / i386

Annotation of coherent/b/STREAMS/i386/memory.s, revision 1.1

1.1     ! root        1: / memory-move operations for the Coherent kernel. The functions called here
        !             2: / do exactly the same thing as the regular C library version.
        !             3: 
        !             4:                .unixorder
        !             5: 
        !             6:                .globl  memset
        !             7: 
        !             8: dest           =       4
        !             9: ch             =       8
        !            10: len            =       12
        !            11: 
        !            12: memset:
        !            13:                movzxb  ch(%esp), %eax          / Fill pattern to %eax
        !            14:                movl    $0x01010101, %ecx       / Replicate fill byte into
        !            15:                mull    %ecx, %eax              / all of %eax (4 copies)
        !            16:                                                / (overwrites %edx too)
        !            17: 
        !            18:                movl    %edi, %edx              / Save %edi
        !            19:                movl    dest(%esp), %edi        / Get dest to %edi
        !            20: 
        !            21:                movl    len(%esp), %ecx         / Get length
        !            22:                shrl    $2, %ecx                / in longwords
        !            23: 
        !            24:                cld                             / Fill upwards
        !            25:                rep stosl                       / Perform the fill
        !            26: 
        !            27:                jnc     ?noword                 / Skip over residual word copy
        !            28: 
        !            29:                stosw
        !            30: ?noword:
        !            31:                testb   $1, len(%esp)           / Check low part of count
        !            32:                je      ?nobyte                 / Skip over residual byte copy
        !            33: 
        !            34:                stosb
        !            35: ?nobyte:
        !            36:                movl    %edx, %edi              / Restore %edi
        !            37:                movl    dest(%esp), %eax        / Return destination
        !            38:                ret
        !            39: 
        !            40: 
        !            41:                .globl  memcpy
        !            42: 
        !            43: dest           =       4
        !            44: src            =       8
        !            45: len            =       12
        !            46: 
        !            47: memcpy:
        !            48:                movl    %esi, %eax              / Save %esi
        !            49:                movl    src(%esp), %esi         / Get src
        !            50: 
        !            51:                movl    %edi, %edx              / Save %edi
        !            52:                movl    dest(%esp), %edi        / Get dest
        !            53: 
        !            54:                movl    len(%esp), %ecx         / Get length
        !            55:                shrl    $2, %ecx                / in longwords
        !            56: 
        !            57:                cld                             / Copy upwards
        !            58:                rep movsl                       / in longwords
        !            59: 
        !            60:                jnc     ?noword                 / Skip residual word copy
        !            61: 
        !            62:                movsw
        !            63: ?noword:
        !            64:                testb   $1, len(%esp)           / Check low byte of length
        !            65:                je      ?nobyte                 / Skip residual byte copy
        !            66: 
        !            67:                movsb
        !            68: ?nobyte:
        !            69:                movl    %edx, %edi              / Restore %edi
        !            70:                movl    %eax, %esi              / Restore %esi
        !            71:                movl    dest(%esp), %eax        / Return destination
        !            72:                ret
        !            73: 
        !            74: / String comparison with length limit.
        !            75: 
        !            76:                .globl  strncmp
        !            77: 
        !            78: left           =       4
        !            79: right          =       8
        !            80: len            =       12
        !            81: 
        !            82: strncmp:
        !            83:                movl    len(%esp), %ecx         / Maximum length
        !            84:                jecxz   ?strncmp_empty
        !            85: 
        !            86:                movl    %esi, %edx              / Preserve %esi
        !            87:                movl    left(%esp), %esi        / Get left
        !            88: 
        !            89:                pushl   %edi                    / Preserve %edi
        !            90:                movl    right+4(%esp), %edi     / Get right, adjusting the
        !            91:                                                / stack offset for push
        !            92: 
        !            93:                cld                             / Scan upwards
        !            94:                xorl    %eax, %eax              / Zero top bytes in %eax
        !            95: 
        !            96: ?strncmp_loop: lodsb                           / %al = * %ds:%esi ++
        !            97:                scasb                           / * %es:%edi ++ - %al ?
        !            98:                jne     ?strncmp_noteq
        !            99:                orb     %al, %al                / %al == 0 ?
        !           100:                loopne  ?strncmp_loop
        !           101: 
        !           102: / Either %al == 0 or %ecx == 0, and we have a match. Zero %eax
        !           103:                xorl    %eax, %eax
        !           104:                popl    %edi                    / Restore %edi
        !           105:                movl    %edx, %esi              / Restore %esi
        !           106:                ret
        !           107: 
        !           108: ?strncmp_noteq:
        !           109:                movb    $1, %al
        !           110:                ja      ?strncmp_less           / Branch if %al was > * right
        !           111:                                                / hence return %eax == 1
        !           112:                negl    %eax                    / Here if %al < * right,
        !           113:                                                / hence return %eax == -1
        !           114: ?strncmp_less:
        !           115:                popl    %edi                    / Restore %edi
        !           116:                movl    %edx, %esi              / Restore %esi
        !           117:                ret
        !           118: 
        !           119: ?strncmp_empty:        xorl    %eax, %eax              / Count == 0 => left == right
        !           120:                ret

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