// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\common\win32\cmem.cpp

//

//

#include "common.h"

#ifdef __MEMMOVE_MACHINE_CODED__

extern "C" {

// See header file e32cmn.h for the in-source documentation.

EXPORT_C __NAKED__ TAny* memmove(TAny* , const TAny* , unsigned int)

	{

	_asm push      ebx							; // Save used registers

	_asm push      esi

	_asm push      edi

	_asm push      ebp

	_asm cmp       dword ptr [esp+0x1c],0x0		; // Is aLength == 0?

	_asm mov       eax,dword ptr [esp+0x14]		; // Ptr to destination

	_asm mov       ebx,dword ptr [esp+0x18]		; // Ptr to source

	_asm je        End							; // aLength is 0, just return

	_asm mov       ecx,eax						; // Copy destination

	_asm xor       ebp,ebp						; // ebp = 0

	_asm test      ecx,0x3						; // Dest word aligned?

	_asm mov       edx,ebx						; // Copy ptr to source

	_asm jne       Misaligned					; // No

	_asm test      edx,0x3						; // Source word aligned?

	_asm jne       Misaligned					; // No

	_asm mov       ebp,dword ptr [esp+0x1c]		; // ebp = aLength

	_asm shr       ebp,0x2						; // ebp = aLength in words

Misaligned:

	_asm lea       edx,dword ptr [ebp*4+0x0]	; // edx = aLength in words

	_asm sal       ebp,0x2						; // ebp = aLength in bytes

	_asm add       ebp,ecx						; // Point to end of destination

	_asm mov       edi,dword ptr [esp+0x1c]		; // Get number of bytes to copy

	_asm sub       edi,edx						; // Find remainder (aLength % 3)

	_asm cmp       eax,ebx						; // Dest >= source?

	_asm mov       edx,ebp						; // Ptr to end of destination

	_asm jae       DoDescendingCopy				; // Yes, copy downwards

	_asm jmp       AscendingCopy				; // No, copy upwards

AscendingCopyLoop:

	_asm mov       ebp,dword ptr [ebx]			; // Get a word

	_asm mov       dword ptr [ecx],ebp			; // And store it

	_asm add       ebx,0x4						; // Increment source by a word

	_asm add       ecx,0x4						; // Increment destination by a word

AscendingCopy:

	_asm cmp       ecx,edx						; // Still data to copy?

	_asm jb        AscendingCopyLoop			; // Yes

	_asm mov       ebp,eax						; // Copy ptr to destination

	_asm add       ebp,dword ptr [esp+0x1c]		; // Point to end of destination

	_asm jmp       CopyRemainder				; // Copy left over (aLength % 3) bytes

CopyRemainderLoop:

	_asm movzx     edx,byte ptr [ebx]			; // Get a byte

	_asm mov       byte ptr [ecx],dl			; // And store it

	_asm inc       ebx							; // Increment source by a byte

	_asm inc       ecx							; // Increment destination by a byte

CopyRemainder:

	_asm cmp       ecx,ebp						; // Any remaining bytes to copy?

	_asm jb        CopyRemainderLoop			; // Yes, go do it

	_asm jmp       End							; // All done

DoDescendingCopy:

	_asm cmp       eax,ebx						; // Still data to copy?

	_asm jbe       End							; // No, all done

	_asm lea       esi,dword ptr [edi+ebp]		; // Get ptr to end of destination

	_asm mov       edi,ebx						; // Get ptr to source

	_asm add       edi,dword ptr [esp+0x1c]		; // Point to end of source

	_asm jmp       DescendingCopyRemainder		; // Copy copy some data

DescendingCopyRemainderLoop:

	_asm dec       edi							; // Decrement source by a byte

	_asm dec       esi							; // Decrement dest by a byte

	_asm movzx     ebx,byte ptr [edi]			; // Get a byte

	_asm mov       byte ptr [esi],bl			; // And store it

DescendingCopyRemainder:

	_asm cmp       esi,ebp						; // Still data to copy?

	_asm ja        DescendingCopyRemainderLoop	; // Yes, go do it

	_asm jmp       DescendingCopy				; // Go copy the bulk of the data

DescendingCopyLoop:

	_asm sub       edi,0x4						; // Decrement source by a word

	_asm sub       edx,0x4						; // Decrement dest by a word

	_asm mov       ebx,dword ptr [edi]			; // Get a word

	_asm mov       dword ptr [edx],ebx			; // And store it

DescendingCopy:

	_asm cmp       edx,ecx						; // Still data to copy

	_asm ja        DescendingCopyLoop			; // Yes, go do it

End:

	_asm pop       ebp							; // Restore used registers

	_asm pop       edi

	_asm pop       esi

	_asm pop       ebx

	_asm ret

	}

// See header file e32cmn.h for the in-source documentation.

EXPORT_C __NAKED__ TAny* memcpy(TAny* , const TAny* , unsigned int)

	{

	__asm jmp (memmove);						; // memmove() will perform the same function

	}

}

#endif // defined(__MEMMOVE_MACHINE_CODED__)