// Copyright (c) 1995-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\arm\cmem.cia

// 

//

#include "../common.h"

#include <e32cia.h>

#if defined(__REPLACE_GENERIC_UTILS)

#include "replacement_utils.h"

#endif

#if defined(__MEM_MACHINE_CODED__)

#ifndef USE_REPLACEMENT_MEMSET

#if defined(_DEBUG)

#ifdef __STANDALONE_NANOKERNEL__

#define ARM_ASSERT_MULTIPLE_OF_FOUR(rt1, panicfunc)	\

	asm("tst "#rt1", #3"); \

	asm("ldrne "#rt1", ["#rt1"]")

#else	// __STANDALONE_NANOKERNEL__

GLDEF_C void PanicEWordMoveLengthNotMultipleOf4();

GLDEF_C void PanicEWordMoveSourceNotAligned();

GLDEF_C void PanicEWordMoveTargetNotAligned();

#define ARM_ASSERT_MULTIPLE_OF_FOUR(rt1, panicfunc)	\

	asm("tst "#rt1", #3"); \

	asm("bne " panicfunc )

#endif	// __STANDALONE_NANOKERNEL__

#else	// _DEBUG

#define ARM_ASSERT_MULTIPLE_OF_FOUR(rt1, panicfunc)

#endif	//_DEBUG

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

extern "C" EXPORT_C __NAKED__ TAny* memclr(TAny* /*aTrg*/, unsigned int /*aLength*/)

	{

	KMEMCLRHOOK

	asm("mov r2, #0 ");

	asm("b fill ");

	}

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

extern "C" EXPORT_C __NAKED__ TAny* memset(TAny* /*aTrg*/, TInt /*aValue*/, unsigned int /*aLength*/)

    {

    KMEMSETHOOK

    asm("   mov		 r3, r2 ");				/* length into r3 */

    asm("   and      r2,r1,#255");			/* fill value into r2 */

	asm("	mov		 r1, r3 ");				/* length into r1 */

    asm("fill:");

    asm("   cmp      r1,#8");

	asm("   bls      small_fill");			// only taken ~20% of the time

    asm("   stmfd    sp!,{r0,r4-r9,lr}");

	asm("   movs     r3, r0, lsl #30 ");	// Check if word aligned

	asm("   orr      r2,r2,r2,lsl #8");

    asm("   orr      r2,r2,r2,lsl #16");

	asm("   bne		 unaligned_fill ");

	// Align destination address to 32 byte boundary if possible

	asm("word_aligned_fill: ");

    asm("   mov      r4,r2");

    asm("   mov      r5,r2");

    asm("   mov      r6,r2");

	asm("   movs     r3, r0, lsl #27 ");

    asm("   beq      aligned_fill ");

    asm("   rsb      r3, r3, #0 ");				// calculate fill length necessary for aligment

	asm("   cmp      r1, r3, lsr #27 ");		// compare with remaining length

	asm("   blo		 smaller_fill ");			// skip alignment if greater

	asm("   msr      cpsr_f, r3 ");				// put length bits 4, 3, 2 into N, Z, C flags

    asm("   strcs    r2, [r0], #4 ");			// align to 8 byte boundary

    asm("   stmeqia  r0!, {r2, r4} ");			// align to 16 byte boundary

    asm("   stmmiia  r0!, {r2, r4-r6} ");		// align to 32 byte boundary

	asm("   sub      r1, r1, r3, lsr #27 ");	// adjust remaining length

    asm("aligned_fill:");

	asm("   cmp		 r1, #64 ");

	asm("   bhs		 big_fill ");

	// Fill 0-63 bytes

    asm("smaller_fill:");

    asm("   movs     r1, r1, lsl #26");

	asm("	beq		 mem_fill_end ");

    asm("   msr      cpsr_flg, r1 ");

    asm("   stmmiia  r0!,{r2,r4-r6}");	// Fill 32

    asm("   stmmiia  r0!,{r2,r4-r6}");

    asm("   stmeqia  r0!,{r2,r4-r6}");	// Fill 16

    asm("   stmcsia  r0!,{r2,r4}");		// Fill 8

    asm("   strvs    r2,[r0],#4");		// Fill 4

	asm("   movs	 r1, r1, lsl #4 ");

	asm("	bne		 smallest_fill ");

	asm("mem_fill_end: ");

	__POPRET("r0,r4-r9,");

	// Fill last 1-3 bytes

    asm("smallest_fill: ");

    asm("   msr      cpsr_flg,r1");

    asm("   strmih   r2,[r0],#2");  	// Fill 2

    asm("   streqb   r2,[r0],#1");  	// Fill 1

	__POPRET("r0,r4-r9,");

	// Fill loop for length >= 64

	asm("big_fill: ");

	asm("   mov      r3,r2");

    asm("   mov      r7,r2");

    asm("   mov      r8,r2");

    asm("   mov      r9,r2");

    asm("   movs     ip,r1,lsr #8");	// Number of 256 byte blocks to fill

	asm("   beq		 medium_fill ");

    asm("fill_256_bytes_loop:");

    asm("   stmia    r0!,{r2-r9}");		// Fill 256 bytes

    asm("   stmia    r0!,{r2-r9}");

    asm("   stmia    r0!,{r2-r9}");

    asm("   stmia    r0!,{r2-r9}");

    asm("   stmia    r0!,{r2-r9}");

    asm("   stmia    r0!,{r2-r9}");

    asm("   stmia    r0!,{r2-r9}");

    asm("   stmia    r0!,{r2-r9}");

    asm("   subs     ip,ip,#1");

    asm("   bne      fill_256_bytes_loop");

	asm("medium_fill: ");

    asm("   movs     ip,r1,lsl #24");

    asm("   msr      cpsr_flg,ip");	

    asm("   stmmiia  r0!,{r2-r9}");		// Fill 128

    asm("   stmmiia  r0!,{r2-r9}");  

    asm("   stmmiia  r0!,{r2-r9}"); 

    asm("   stmmiia  r0!,{r2-r9}"); 

    asm("   stmeqia  r0!,{r2-r9}");		// Fill 64

    asm("   stmeqia  r0!,{r2-r9}"); 

	asm("   and		 r1, r1, #63 ");

	asm("   b 		 smaller_fill");

	// Word-align destination address, length >= 8

	asm("unaligned_fill: ");

    asm("   rsb      r3, r3, #0 ");				// calculate fill length necessary for aligment

    asm("   msr      cpsr_flg, r3");

	asm("   streqb   r2, [r0], #1 ");			// align to 2 byte boundary

    asm("   strmih   r2, [r0], #2 ");			// align to 4 byte boundary

	asm("   sub      r1, r1, r3, lsr #30 ");

	asm("	b		 word_aligned_fill ");

	// Fill for length <= 8

	asm("small_fill: ");

	asm("	mov		 r3, r0 ");				/* r3=dest */

	asm("   adr      ip, small_fill_end ");

	asm("   sub		 pc, ip, r1, lsl #2 ");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

    asm("   strb     r2, [r3], #1");

	asm("small_fill_end: ");

	__JUMP(,lr);

#ifdef __EABI__

	// The AEABI switched the order of arg2 and arg3 to save an intruction when

	// calling 'memset' from 'memclr'	

	asm(".global __aeabi_memset8 ");

	asm("__aeabi_memset8: 		 ");

	asm(".global __aeabi_memset4 ");

	asm("__aeabi_memset4: 		 ");

	asm(".global __aeabi_memset  ");

	asm("__aeabi_memset: 		 ");

    asm("   and      r2, r2, #255");

	asm("	b		 fill		 ");

#endif

    }

#endif  // USE_REPLACEMENT_MEMSET

#ifndef USE_REPLACEMENT_MEMCPY

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

extern "C" EXPORT_C __NAKED__ TAny* wordmove(TAny* /*aTrg*/, const TAny* /*aSrc*/, unsigned int /*aLength*/)

//

// Assumes all is aligned

//

    {

	ARM_ASSERT_MULTIPLE_OF_FOUR(r0, CSM_Z30PanicEWordMoveTargetNotAlignedv);

	ARM_ASSERT_MULTIPLE_OF_FOUR(r1, CSM_Z30PanicEWordMoveSourceNotAlignedv);

	ARM_ASSERT_MULTIPLE_OF_FOUR(r2, CSM_Z34PanicEWordMoveLengthNotMultipleOf4v);

	// Mask length to a multiple of four bytes to avoid memory, or register

	// corruption by the special cases below.

	asm("bic r2,r2,#3");

	// Length <= 24 in ~90% of cases, however can only copy > 16 bytes in 4

	// instructions if LDM instuction restores thumb state when loading the PC.	

#ifdef __CPU_ARM_LDR_PC_SETS_TBIT

	asm("cmp r2, #24 ");

#else

	asm("cmp r2, #16 ");

#endif

	PLD(1);

	asm("addls pc, pc, r2, lsl #2 ");		// take branch depending on size

	asm("b 9f ");							// too big

	// 0 words

	__JUMP(,lr);

	__JUMP(,lr);

	__JUMP(,lr);

	__JUMP(,lr);

	// 1 word

	asm("ldr ip, [r1] ");

	asm("str ip, [r0] ");

	__JUMP(,lr);

	__JUMP(,lr);

	// 2 words

	asm("ldmia r1, {r2,r3}");

	asm("stmia r0, {r2,r3}");

	__JUMP(,lr);

	__JUMP(,lr);

	// 3 words

	asm("ldmia r1, {r2,r3,ip}");

	asm("stmia r0, {r2,r3,ip}");

	__JUMP(,lr);

	__JUMP(,lr);

	// 4 words

	asm("ldmia r1, {r1,r2,r3,ip}");

	asm("stmia r0, {r1,r2,r3,ip}");

	__JUMP(,lr);

	__JUMP(,lr);

#ifdef __CPU_ARM_LDR_PC_SETS_TBIT

	// 5 words

	asm("stmfd sp!, {lr}");

	asm("ldmia r1, {r1,r2,r3,ip,lr}");

	asm("stmia r0, {r1,r2,r3,ip,lr}");

	asm("ldmfd sp!, {pc}");

	// 6 words

	asm("stmfd sp!, {r4,lr}");

	asm("ldmia r1, {r1,r2,r3,r4,ip,lr}");

	asm("stmia r0, {r1,r2,r3,r4,ip,lr}");

	asm("ldmfd sp!, {r4,pc}");

#endif

	asm("9: ");

    asm("subs r3, r0, r1 ");				// r3 = dest - source

	__JUMP(eq,lr);							// return if source = dest

    asm("stmfd sp!, {r0,r4-r11,lr} ");

	asm("cmphi r2, r3 ");					// if dest>source, compare length with dest-source

    asm("bls mem_move_fore ");				// if dest<source or length<=dest-source do forwards aligned copy

    asm("add r0, r0, r2 ");

    asm("add r1, r1, r2 ");

    asm("b mem_move_back ");				// Backwards aligned copy

    }

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

extern "C" EXPORT_C __NAKED__ TAny* memmove(TAny* /*aTrg*/, const TAny* /*aSrc*/, unsigned int /*aLength*/)

	{

	KMEMMOVEHOOK

	// fall through

	}

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

extern "C" EXPORT_C __NAKED__ TAny* memcpy(TAny* /*aTrg*/, const TAny* /*aSrc*/, unsigned int /*aLength*/)

    {

    KMEMCPYHOOK

//

// Check for zero length or source and target being the same

//

    asm("	cmp		r2, #0 ");				// zero length?

    asm("	subnes	r3, r0, r1 ");			// if not, r3 = dest-source

	__JUMP(eq,lr);							// if zero length or dest=source, nothing to do

	asm("	cmphi	r2, r3 ");				// if dest>source compare length to dest-source

	asm("	movhi	r3, #0 ");				// if dest>source and length>dest-source need to go backwards - set r3=0

//

//	If <16 bytes, just do byte moves

//

    asm("	cmp		r2,	#15 ");

	asm("	bhi		main_copy ");

	asm("	ldrb	r12, [r0] ");			// read dest so it's in cache - avoid lots of single accesses to external memory

	asm("	sub		r12, r0, #1 ");

	asm("	ldrb	r12, [r12, r2] ");		// read dest+length-1

	asm("	cmp		r3, #0 ");

	asm("	beq		small_copy_back ");		// r3=0 means go backwards

	asm("small_copy_fwd: ");

	asm("	mov		r3, r0 ");

	asm("	adr		r12, small_copy_fwd_end ");

	asm("	sub		pc, r12, r2, lsl #3 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("	ldrb	r12, [r1], #1 ");

	asm("	strb	r12, [r3], #1 ");

	asm("small_copy_fwd_end: ");

	__JUMP(,lr);

	asm("small_copy_back: ");

	asm("	add		r3, r0, r2 ");

	asm("	add		r1, r1, r2 ");

	asm("	adr		r12, small_copy_back_end ");

	asm("	sub		pc, r12, r2, lsl #3 ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("	ldrb	r12, [r1, #-1]! ");

	asm("	strb	r12, [r3, #-1]! ");

	asm("small_copy_back_end: ");

	__JUMP(,lr);

	asm("main_copy: ");

	PLD(1);											// preload first two cache lines

	PLD_ioff(1, 32);

	asm("	stmfd	sp!, {r0,r4-r11,lr} ");			// r0 == dest, r1 == src, r2 == len

	asm("	cmp		r3, #0 ");

	asm("	beq		copy_back ");					// we must go backwards

    asm("   movs	r3, r0, lsl #30 ");				// check destination word aligned

	asm("   bne		dest_unaligned_fore ");

//

// Normal copy forwards. r0 should point to end address on exit

// Destination now word-aligned; if source is also word-aligned, do aligned copy.

//	

	asm("dest_aligned_fore: ");

    asm("   ands	r12, r1, #3 ");		// r12=alignment of source

    asm("   bne		copy_fwd_nonaligned ");

//

// We are now word aligned, at least 13 bytes to do

//

    asm("mem_move_fore:");

//

// superalign

//

    asm("	movs	r4, r0, lsl #27 ");		 		 		// destination alignment into r4

	asm("	beq		f_al_already_aligned ");				// fast path

	asm("	rsb		r4, r4, #0 ");							// bytes required to align destination to 32

	asm("	cmp		r2, r4, lsr #27 ");						// check that many remaining

	asm("	blo		its_smaller_fore ");					// if too short, just stick with word alignment

	asm("	msr		cpsr_flg, r4 ");		 		 		// destination alignment into N, Z, C flags

															// do word moves to align destination

	asm("	ldrcs	lr, [r1], #4 ");						// C flag == 1 word (we are already word aligned)

	asm("	ldmeqia	r1!, {r3,r9} ");						// Z flag == 2 words

	asm("	ldmmiia	r1!, {r5-r8} ");						// N flag == 4 words, destination now 32 byte aligned

	asm("	sub		r2, r2, r4, lsr #27 ");		 			// adjust length

	asm("	strcs	lr, [r0], #4 ");						// destination now 8 byte aligned

	asm("	stmeqia	r0!, {r3,r9} ");						// destination now 16 byte aligned

	asm("	stmmiia	r0!, {r5-r8} ");						// destination now 32 byte aligned	

	asm("f_al_already_aligned: ");

	asm("	cmp		r2, #64 ");

	asm("	bhs		large_copy_fore ");

//

// Less than 64 bytes to go...

//	

    asm("its_smaller_fore:");

    asm("	movs	ip, r2, lsl #26 ");		// length bits 5, 4, 3, 2 into N, Z, C, V

	asm("	beq		mem_copy_end ");		// skip if remaining length zero

    asm("	msr		cpsr_flg, ip ");

    asm("	ldmmiia	r1!, {r3-r10} ");

    asm("	stmmiia	r0!, {r3-r10} ");		// copy 32	

    asm("	ldmeqia	r1!, {r3-r6} ");

    asm("	ldmcsia	r1!, {r7-r8} ");

    asm("	ldrvs	r9, [r1], #4 ");

    asm("	stmeqia	r0!, {r3-r6} ");		// copy 16

    asm("	stmcsia	r0!, {r7-r8} ");		// copy 8

    asm("	strvs	r9, [r0], #4 ");		// copy 4

    asm("	movs	ip, r2, lsl #30 ");	

	asm("	bne		smallest_copy_fore ");

	asm("mem_copy_end: ");

	__POPRET("r0,r4-r11,");

//

// Less than 4 bytes to go...

//

	asm("smallest_copy_fore: ");

    asm("	msr		cpsr_flg, ip ");

    asm("	ldrmih	r3, [r1], #2 ");

    asm("	ldreqb	r4, [r1], #1 ");

    asm("	strmih	r3, [r0], #2 ");		// copy 2

    asm("	streqb	r4, [r0], #1 ");		// copy 1

	__POPRET("r0,r4-r11,");

//

// Do byte moves if necessary to word-align destination

//

	asm("dest_unaligned_fore: ");

	asm("	rsb		r3, r3, #0 ");

	asm("	msr		cpsr_flg, r3 ");

	asm("	ldrmib	r4, [r1], #1 ");				// move bytes to align destination

	asm("	ldrmib	r5, [r1], #1 ");

	asm("	ldreqb	r6, [r1], #1 ");

	asm("	sub		r2, r2, r3, lsr #30 ");			// adjust length, at least 13 bytes remaining

	asm("	strmib	r4, [r0], #1 ");

	asm("	strmib	r5, [r0], #1 ");

	asm("	streqb	r6, [r0], #1 ");

	asm("   b		dest_aligned_fore ");

//

//	Large copy, length >= 64

//

	asm("large_copy_fore: ");

	asm("	movs	ip, r2, lsr #6 ");						// ip = number of 64 blocks to copy

	asm("1: ");

	PLD_ioff(1, 32);

	PLD_ioff(1, 64);

    asm("	ldmia	r1!, {r3-r10} ");		// Copy 64

    asm("	stmia	r0!, {r3-r10} "); 

    asm("	ldmia	r1!, {r3-r10} ");

    asm("	subs	ip, ip, #1 ");

    asm("	stmia	r0!, {r3-r10} "); 	

	asm("	bne		1b ");		

	asm("	and		r2, r2, #63 ");

	asm("	b		its_smaller_fore ");

//

// Forward unlaigned copy

//	

	asm("copy_fwd_nonaligned:");

//

// superalign

//	

	asm("	bic		r1, r1, #3 ");					// align source

	asm("	ldr		r11, [r1], #4 ");				// get first word

	asm("	mov		r12, r12, lsl #3 ");			// r12 = 8*source alignment

	asm("	ands	r4, r0, #31 ");					// destination alignment into r4

	asm("	beq		medium_unal_copy ");			// skip if already aligned

	asm("	rsb		r4, r4, #32 ");					// r4 = bytes to align dest to 32

	asm("	cmp		r2, r4 ");						// check if length big enough to align to 32

	asm("	blo		copy_fwd_remainder ");			// skip if too small

	asm("	sub		r2, r2, r4 ");					// adjust length

	asm("	rsb		r3, r12, #32 ");				// r3 = 32 - 8*source alignment

	asm("1: ");

	asm("	mov		r5, r11, lsr r12 ");			// r5 = part of previous source word required to make destination word

	asm("	ldr		r11, [r1], #4 ");				// get next word

	asm("	subs	r4, r4, #4 ");					// 4 bytes less to do

	asm("	orr		r5, r5, r11, lsl r3 ");			// form next destination word

	asm("	str		r5, [r0], #4 ");				// and store it

	asm("	bne		1b ");							// loop until destination 32 byte aligned

	asm("medium_unal_copy: ");						// destination now aligned to 32 bytes

	asm("	movs	lr, r2, lsr #5 ");				// lr=number of 32-byte blocks

	asm("	beq		copy_fwd_remainder ");			// skip if length < 32

	asm("	cmp		r12, #16 ");

	asm("	beq		copy_fwd_nonaligned_2 ");		// branch if source = 2 mod 4

	asm("	bhi		copy_fwd_nonaligned_3 ");		// branch if source = 3 mod 4, else source = 1 mod 4

// source = 1 mod 4

	asm("copy_fwd_nonaligned_1: ");

	asm("	mov		r3, r11, lsr #8 ");

	asm("	ldmia	r1!, {r4-r11} ");

	PLD_ioff(1, 32);

	asm("	subs	lr, lr, #1 ");

	asm("	orr		r3, r3, r4, lsl #24 ");

	asm("	mov		r4, r4, lsr #8 ");

	asm("	orr		r4, r4, r5, lsl #24 ");

	asm("	mov		r5, r5, lsr #8 ");

	asm("	orr		r5, r5, r6, lsl #24 ");

	asm("	mov		r6, r6, lsr #8 ");

	asm("	orr		r6, r6, r7, lsl #24 ");

	asm("	mov		r7, r7, lsr #8 ");

	asm("	orr		r7, r7, r8, lsl #24 ");

	asm("	mov		r8, r8, lsr #8 ");

	asm("	orr		r8, r8, r9, lsl #24 ");

	asm("	mov		r9, r9, lsr #8 ");

	asm("	orr		r9, r9, r10, lsl #24 ");

	asm("	mov		r10, r10, lsr #8 ");

	asm("	orr		r10, r10, r11, lsl #24 ");

	asm("	stmia	r0!, {r3-r10} ");

	asm("	bne		copy_fwd_nonaligned_1 ");

	asm("	b		copy_fwd_remainder ");

// source = 2 mod 4

	asm("copy_fwd_nonaligned_2: ");

	asm("	mov		r3, r11, lsr #16 ");

	asm("	ldmia	r1!, {r4-r11} ");

	PLD_ioff(1, 32);

	asm("	subs	lr, lr, #1 ");

	asm("	orr		r3, r3, r4, lsl #16 ");

	asm("	mov		r4, r4, lsr #16 ");

	asm("	orr		r4, r4, r5, lsl #16 ");

	asm("	mov		r5, r5, lsr #16 ");

	asm("	orr		r5, r5, r6, lsl #16 ");

	asm("	mov		r6, r6, lsr #16 ");

	asm("	orr		r6, r6, r7, lsl #16 ");

	asm("	mov		r7, r7, lsr #16 ");

	asm("	orr		r7, r7, r8, lsl #16 ");

	asm("	mov		r8, r8, lsr #16 ");

	asm("	orr		r8, r8, r9, lsl #16 ");

	asm("	mov		r9, r9, lsr #16 ");

	asm("	orr		r9, r9, r10, lsl #16 ");

	asm("	mov		r10, r10, lsr #16 ");

	asm("	orr		r10, r10, r11, lsl #16 ");

	asm("	stmia	r0!, {r3-r10} ");

	asm("	bne		copy_fwd_nonaligned_2 ");

	asm("	b		copy_fwd_remainder ");

// source = 3 mod 4

	asm("copy_fwd_nonaligned_3: ");

	asm("	mov		r3, r11, lsr #24 ");

	asm("	ldmia	r1!, {r4-r11} ");

	PLD_ioff(1, 32);

	asm("	subs	lr, lr, #1 ");

	asm("	orr		r3, r3, r4, lsl #8 ");

	asm("	mov		r4, r4, lsr #24 ");

	asm("	orr		r4, r4, r5, lsl #8 ");

	asm("	mov		r5, r5, lsr #24 ");

	asm("	orr		r5, r5, r6, lsl #8 ");

	asm("	mov		r6, r6, lsr #24 ");

	asm("	orr		r6, r6, r7, lsl #8 ");

	asm("	mov		r7, r7, lsr #24 ");

	asm("	orr		r7, r7, r8, lsl #8 ");

	asm("	mov		r8, r8, lsr #24 ");

	asm("	orr		r8, r8, r9, lsl #8 ");

	asm("	mov		r9, r9, lsr #24 ");

	asm("	orr		r9, r9, r10, lsl #8 ");

	asm("	mov		r10, r10, lsr #24 ");

	asm("	orr		r10, r10, r11, lsl #8 ");

	asm("	stmia	r0!, {r3-r10} ");

	asm("	bne		copy_fwd_nonaligned_3 ");

// <32 bytes to go, source alignment could be 1, 2 or 3 mod 4

// r12 = 8 * (source mod 4)

	asm("copy_fwd_remainder: ");

	asm("	ands	r4, r2, #0x1c ");			// r4 = 4*number of words left

	asm("	beq		2f ");						// skip if none

	asm("	rsb		r3, r12, #32 ");			// r3 = 32 - 8*source alignment

	asm("1: ");

	asm("	mov		r5, r11, lsr r12 ");		// r5 = part of previous source word required to make destination word

	asm("	ldr		r11, [r1], #4 ");			// get next word

	asm("	subs	r4, r4, #4 ");				// 4 bytes less to do

	asm("	orr		r5, r5, r11, lsl r3 ");		// form next destination word

	asm("	str		r5, [r0], #4 ");			// and store it

	asm("	bne		1b ");						// loop until destination 32 byte aligned

	asm("2: ");

	asm("	sub		r1, r1, #4 ");

	asm("	add		r1, r1, r12, lsr #3 ");		// r1 = real unaligned source address

	asm("	tst		r2, #2 ");					// 2 bytes left?

	asm("	ldrneb	r5, [r1], #1 ");			// copy 2

	asm("	strneb	r5, [r0], #1 ");

	asm("	ldrneb	r5, [r1], #1 ");

	asm("	strneb	r5, [r0], #1 ");

	asm("	tst		r2, #1 ");					// 1 byte left?

	asm("	ldrneb	r5, [r1], #1 ");			// copy 1

	asm("	strneb	r5, [r0], #1 ");

	__POPRET("r0,r4-r11,");

//

// Source is before destination and they overlap, so need to copy backwards

//

    asm("copy_back:");

	asm("	add		r0, r0, r2 ");				// r0=last dest address+1

	asm("	add		r1, r1, r2 ");				// r1=last source address+1

	PLD_noff(1, 33);							// preload last two cache lines

	PLD_noff(1, 1);

    asm("	movs	r3, r0, lsl #30 ");			// check destination word aligned

	asm("	bne		dest_unaligned_back ");

	asm("dest_aligned_back: ");

	asm("	ands	r12, r1, #3 ");					// r12=alignment of source

    asm("	bne		copy_back_nonaligned ");

//

// Backwards copying, addresses both word aligned, at least 13 bytes to go

//

    asm("mem_move_back:");

//

// superalign

// 

	asm("	movs	r4, r0, lsl #27 ");					// bytes required to align destination to 32

	asm("	beq		bal_already_aligned ");				// skip if already aligned to 32

	asm("	cmp		r2, r4, lsr #27 ");					// check that many remaining

	asm("	blo		its_smaller_back ");				// if too short, just stick with word alignment

	asm("	msr		cpsr_flg, r4 ");		 		 	// destination alignment into N, Z, C flags

														// do word moves to align destination

	asm("	ldrcs	lr, [r1, #-4]! ");					// C flag == 1 word (we are already word aligned)

	asm("	ldmeqdb	r1!, {r3,r9} ");					// Z flag == 2 words

	asm("	ldmmidb	r1!, {r5-r8} ");

	asm("	sub		r2, r2, r4, lsr #27 ");		 		// adjust length

	asm("	strcs	lr, [r0, #-4]! ");					// destination now 8 byte aligned

	asm("	stmeqdb	r0!, {r3,r9} ");					// destination now 16 byte aligned

	asm("	stmmidb	r0!, {r5-r8} ");					// N flag == 4 words, destination now 32 byte aligned

	asm("bal_already_aligned: ");

	asm("	cmp		r2, #64 ");

	asm("	bhs		large_copy_back ");

//

// Less than 64 bytes to go

//

    asm("its_smaller_back: ");

    asm("	movs	ip, r2, lsl #26 ");		// r2 = remaining length (<256) << 24

	asm("	beq		mem_copy_end2 ");		// skip if remaining length zero

    asm("	msr		cpsr_flg, ip ");

    asm("	ldmmidb	r1!, {r3-r10} ");

    asm("	stmmidb	r0!, {r3-r10} ");		// copy 32

    asm("	ldmeqdb	r1!, {r3-r6} ");

    asm("	ldmcsdb	r1!, {r7,r8} ");

    asm("   ldrvs	r9, [r1, #-4]! ");

    asm("	stmeqdb	r0!, {r3-r6} ");		// copy 16

    asm("	stmcsdb	r0!, {r7,r8} ");		// copy 8

    asm("   strvs	r9, [r0, #-4]! ");		// copy 4

    asm("	movs	ip, r2, lsl #30 ");

	asm("	bne		smallest_copy_back ");

	asm("mem_copy_end2: ");

	__POPRET("r0,r4-r11,");

//

// Less than 4 bytes to go...

//

	asm("smallest_copy_back: ");

    asm("	msr		cpsr_flg, ip ");

    asm("	ldrmih	r3, [r1, #-2]! ");

    asm("	ldreqb	r4, [r1, #-1]! ");

    asm("	strmih	r3, [r0, #-2]! ");		// copy 2

    asm("	streqb	r4, [r0, #-1]! ");		// copy 1

	__POPRET("r0,r4-r11,");

//

// Do byte moves if necessary to word-align destination

//

	asm("dest_unaligned_back: ");

	asm("	msr		cpsr_flg, r3 ");				// destination alignment in r3 into N,Z flags

	asm("	ldrmib	r4, [r1, #-1]! ");				// do byte moves to align destination

	asm("	ldrmib	r5, [r1, #-1]! ");

	asm("	ldreqb	r6, [r1, #-1]! ");

	asm("	sub		r2, r2, r3, lsr #30 ");			// adjust length, at least 13 bytes remaining

	asm("	strmib	r4, [r0, #-1]! ");

	asm("	strmib	r5, [r0, #-1]! ");

	asm("	streqb	r6, [r0, #-1]! ");

	asm("	b		dest_aligned_back ");

//

//	Large backwards copy, length >= 64

//	

	asm("large_copy_back: ");

    asm("	movs	ip, r2, lsr #6 ");

	asm("1: ");

	PLD_noff(1, 65);

	PLD_noff(1, 33);

    asm("	ldmdb	r1!, {r3-r10} ");		// Copy 64

    asm("	stmdb	r0!, {r3-r10} "); 

    asm("	ldmdb	r1!, {r3-r10} ");

    asm("	subs	ip, ip, #1 ");

    asm("	stmdb	r0!, {r3-r10} "); 

	asm("	bne		1b ");		

	asm("	and		r2, r2, #63 ");

	asm("	b		its_smaller_back ");

//

// Backwards unlaigned copy

//	

	asm("copy_back_nonaligned: ");

//

// superalign

//

	asm("	bic		r1, r1, #3 ");					// align source

	asm("	ldr		r3, [r1] ");					// get first word

	asm("	mov		r12, r12, lsl #3 ");			// r12 = 8*source alignment

	asm("	ands	r4, r0, #31 ");					// r4 = bytes to align dest to 32

	asm("	beq		bunal_already_aligned ");		// skip if already aligned

	asm("	cmp		r2, r4 ");						// check if length big enough to align to 32

	asm("	blo		copy_back_remainder ");			// skip if too small

	asm("	sub		r2, r2, r4 ");					// adjust length

	asm("	rsb		r6, r12, #32 ");				// r6 = 32 - 8*source alignment

	asm("1: ");

	asm("	mov		r5, r3, lsl r6 ");				// r5 = part of previous source word required to make destination word

	asm("	ldr		r3, [r1, #-4]! ");				// get next word

	asm("	subs	r4, r4, #4 ");					// 4 bytes less to do

	asm("	orr		r5, r5, r3, lsr r12 ");			// form next destination word

	asm("	str		r5, [r0, #-4]! ");				// and store it

	asm("	bne		1b ");							// loop until destination 32 byte aligned

	asm("bunal_already_aligned: ");					// destination now aligned to 32 bytes

	asm("	movs	lr, r2, lsr #5 ");				// lr=number of 32-byte blocks

	asm("	beq		copy_back_remainder ");			// skip if length < 32

	asm("	cmp		r12, #16 ");

	asm("	beq		copy_back_nonaligned_2 ");		// branch if source = 2 mod 4

	asm("	bhi		copy_back_nonaligned_3 ");		// branch if source = 3 mod 4, else source = 1 mod 4

// source = 1 mod 4

	asm("copy_back_nonaligned_1: ");

	asm("	mov		r11, r3, lsl #24 ");

	asm("	ldmdb	r1!, {r3-r10} ");

	PLD_noff(1, 64);

	asm("	orr		r11, r11, r10, lsr #8 ");

	asm("	mov		r10, r10, lsl #24 ");

	asm("	orr		r10, r10, r9, lsr #8 ");

	asm("	mov		r9, r9, lsl #24 ");

	asm("	orr		r9, r9, r8, lsr #8 ");

	asm("	mov		r8, r8, lsl #24 ");

	asm("	orr		r8, r8, r7, lsr #8 ");

	asm("	mov		r7, r7, lsl #24 ");

	asm("	orr		r7, r7, r6, lsr #8 ");

	asm("	mov		r6, r6, lsl #24 ");

	asm("	orr		r6, r6, r5, lsr #8 ");

	asm("	mov		r5, r5, lsl #24 ");

	asm("	orr		r5, r5, r4, lsr #8 ");

	asm("	mov		r4, r4, lsl #24 ");

	asm("	orr		r4, r4, r3, lsr #8 ");

	asm("	stmdb	r0!, {r4-r11} ");

	asm("	subs	lr, lr, #1 ");

	asm("	bne		copy_back_nonaligned_1 ");

	asm("	b		copy_back_remainder ");

// source = 2 mod 4

	asm("copy_back_nonaligned_2: ");

	asm("	mov		r11, r3, lsl #16 ");

	asm("	ldmdb	r1!, {r3-r10} ");

	PLD_noff(1, 64);

	asm("	orr		r11, r11, r10, lsr #16 ");

	asm("	mov		r10, r10, lsl #16 ");

	asm("	orr		r10, r10, r9, lsr #16 ");

	asm("	mov		r9, r9, lsl #16 ");

	asm("	orr		r9, r9, r8, lsr #16 ");

	asm("	mov		r8, r8, lsl #16 ");

	asm("	orr		r8, r8, r7, lsr #16 ");

	asm("	mov		r7, r7, lsl #16 ");

	asm("	orr		r7, r7, r6, lsr #16 ");

	asm("	mov		r6, r6, lsl #16 ");

	asm("	orr		r6, r6, r5, lsr #16 ");

	asm("	mov		r5, r5, lsl #16 ");

	asm("	orr		r5, r5, r4, lsr #16 ");

	asm("	mov		r4, r4, lsl #16 ");

	asm("	orr		r4, r4, r3, lsr #16 ");

	asm("	stmdb	r0!, {r4-r11} ");

	asm("	subs	lr, lr, #1 ");

	asm("	bne		copy_back_nonaligned_2 ");

	asm("	b		copy_back_remainder ");

// source = 3 mod 4

	asm("copy_back_nonaligned_3: ");

	asm("	mov		r11, r3, lsl #8 ");

	asm("	ldmdb	r1!, {r3-r10} ");

	PLD_noff(1, 64);

	asm("	orr		r11, r11, r10, lsr #24 ");

	asm("	mov		r10, r10, lsl #8 ");

	asm("	orr		r10, r10, r9, lsr #24 ");

	asm("	mov		r9, r9, lsl #8 ");

	asm("	orr		r9, r9, r8, lsr #24 ");

	asm("	mov		r8, r8, lsl #8 ");

	asm("	orr		r8, r8, r7, lsr #24 ");

	asm("	mov		r7, r7, lsl #8 ");

	asm("	orr		r7, r7, r6, lsr #24 ");

	asm("	mov		r6, r6, lsl #8 ");

	asm("	orr		r6, r6, r5, lsr #24 ");

	asm("	mov		r5, r5, lsl #8 ");

	asm("	orr		r5, r5, r4, lsr #24 ");

	asm("	mov		r4, r4, lsl #8 ");

	asm("	orr		r4, r4, r3, lsr #24 ");

	asm("	stmdb	r0!, {r4-r11} ");

	asm("	subs	lr, lr, #1 ");

	asm("	bne		copy_back_nonaligned_3 ");

// <32 bytes to go, source alignment could be 1, 2 or 3 mod 4

// r12 = 8 * (source mod 4)

	asm("copy_back_remainder: ");

	asm("	ands	r4, r2, #0x1c ");			// r4 = 4*number of words left

	asm("	beq		2f ");						// skip if none

	asm("	rsb		r6, r12, #32 ");			// r6 = 32 - 8*source alignment

	asm("1: ");

	asm("	mov		r5, r3, lsl r6 ");			// r5 = part of previous source word required to make destination word

	asm("	ldr		r3, [r1, #-4]! ");			// get next word

	asm("	subs	r4, r4, #4 ");				// 4 bytes less to do

	asm("	orr		r5, r5, r3, lsr r12 ");		// form next destination word

	asm("	str		r5, [r0, #-4]! ");			// and store it

	asm("	bne		1b ");						// loop until destination 32 byte aligned

	asm("2: ");

	asm("	add		r1, r1, r12, lsr #3 ");		// r1 = real unaligned source address

	asm("	tst		r2, #2 ");					// 2 bytes left?

	asm("	ldrneb	r3, [r1, #-1]! ");			// copy 2

	asm("	strneb	r3, [r0, #-1]! ");

	asm("	ldrneb	r3, [r1, #-1]! ");

	asm("	strneb	r3, [r0, #-1]! ");

	asm("	tst		r2, #1 ");					// 1 byte left?

	asm("	ldrneb	r3, [r1, #-1]! ");			// copy 1

	asm("	strneb	r3, [r0, #-1]! ");

	__POPRET("r0,r4-r11,");

    }

#endif  // USE_REPLACEMENT_MEMCPY

#ifndef __KERNEL_MODE__

#ifdef __GCC32__ 

/**

Compares a block of data at one specified location with a block of data at 

another specified location.

The comparison proceeds on a byte for byte basis, the result of the comparison 

is based on the difference of the first bytes to disagree.

The data at the two locations are equal if they have the same length and content. 

Where the lengths are different and the shorter section of data is the same 

as the first part of the longer section of data, the shorter is considered 

to be less than the longer.

@param aLeft   A pointer to the first (or left) block of 8 bit data

               to be compared.

@param aLeftL  The length of the first (or left) block of data to be compared,  

               i.e. the number of bytes.

@param aRight  A pointer to the second (or right) block of 8 bit data to be 

               compared.

@param aRightL The length of the second (or right) block of data to be compared 

               i.e. the number of bytes.

@return Positive, if the first (or left) block of data is greater than the 

        second (or right) block of data.

        Negative, if the first (or left) block of data is less than the

        second (or right) block of data.

        Zero, if both the first (or left) and second (or right) blocks of data

        have the same length and the same content.

*/

EXPORT_C __NAKED__ TInt Mem::Compare(const TUint8* /*aLeft*/, TInt /*aLeftL*/, const TUint8* /*aRight*/, TInt /*aRightL*/)

	{

	// fall through

	}

#endif

#endif

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

extern "C" EXPORT_C __NAKED__ TInt memcompare(const TUint8* /*aLeft*/, TInt /*aLeftL*/, const TUint8* /*aRight*/, TInt /*aRightL*/)

//

// Compares until the smaller of the two lengths is reached.

// If the lengths differ, returns leftlen-rightlen

// If a difference is encountered, returns left byte-right byte

//

    {

    asm("   stmfd    sp!,{r4,r5,r6,lr}");

    asm("   mov      r4,r0");

//

// Get the shorter of the two lengths, and check for zero length

//

    asm("   cmp      r1,r3");

    asm("   mov      r6,r1");

    asm("   movge    r6,r3");

    asm("   cmp      r6,#0");

    asm("   beq      compare_done");

    asm("   cmp      r6,#16");

//

// Check for aligned buffers for faster comparing if more than 16 bytes

//

    asm("   andge    r0,r4,#3");

    asm("   andge    r5,r2,#3");

    asm("   addlt    r0,r5,#1");

    asm("   cmp      r0,r5");

    asm("   beq      aligned_compare");

//

// Get aLeft+Min(aLeftL,aRightL)

//

    asm("   add      r6,r4,r6");

    asm("compare_loop:");

    asm("   ldrb     r0,[r4],#1");

    asm("   ldrb     r5,[r2],#1");

    asm("   subs     r0,r0,r5");

	asm("bne compare_exit ");

    asm("   cmp      r4,r6");

    asm("   beq      compare_done");

    asm("   ldrb     r0,[r4],#1");

    asm("   ldrb     r5,[r2],#1");

    asm("   subs     r0,r0,r5");

	asm("bne compare_exit ");

    asm("   cmp      r4,r6");

    asm("   beq      compare_done");

    asm("   ldrb     r0,[r4],#1");

    asm("   ldrb     r5,[r2],#1");

    asm("   subs     r0,r0,r5");

	asm("bne compare_exit ");

    asm("   cmp      r4,r6");

    asm("   beq      compare_done");

    asm("   ldrb     r0,[r4],#1");

    asm("   ldrb     r5,[r2],#1");