Subversion Repositories Kolibri OS

# _memmove() Author: Kees J. Bot 2 Jan 1994

# void *_memmove(void *s1, const void *s2, size_t n)

#       Copy a chunk of memory.  Handle overlap.

.intel_syntax

.globl __memmove, __memcpy

.text

           .align  16

__memmove:

           push    ebp

           mov     ebp, esp

           push    esi

           push    edi

           mov     edi, [ebp+8]     # String s1

           mov     esi, [ebp+12]    # String s2

           mov     ecx, [ebp+16]    # Length

           mov     eax, edi

           sub     eax, esi

           cmp     eax, ecx

           jb      downwards        # if (s2 - s1) < n then copy downwards

__memcpy:

           cld                      # Clear direction bit: upwards

           cmp     ecx, 16

           jb      upbyte           # Don't bother being smart with short arrays

           mov     eax, esi

           or      eax, edi

           testb   al, 1

           jnz     upbyte           # Bit 0 set, use byte copy

           testb   al, 2

           jnz     upword           # Bit 1 set, use word copy

uplword:

           shrd    eax, ecx, 2      # Save low 2 bits of ecx in eax

           shr     ecx, 2

           rep movsd                # Copy longwords.

           shld    ecx, eax, 2      # Restore excess count

upword:

           shr     ecx, 1

           rep movsw                # Copy words

           adc     ecx, ecx         # One more byte?

upbyte:

           rep movsb                # Copy bytes

done:

           mov     eax, [ebp+8]     # Absolutely noone cares about this value

           pop     edi

           pop     esi

           pop     ebp

           ret

# Handle bad overlap by copying downwards, don't bother to do word copies.

downwards:

           std                     # Set direction bit: downwards

           lea     esi, [esi+ecx-1]

           lea     edi, [edi+ecx-1]

           rep movsb               # Copy bytes

           cld

           jmp     done