// Copyright (c) 1997-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\klib\arm\cumem.cia

 // 

 //

 #include <kernel/klib.h>

 #include <e32cia.h>

 #include <arm.h>

 #if defined(__REPLACE_GENERIC_UTILS)

 #include "replacement_utils.h"

 #endif

 extern "C" {

 #ifdef _DEBUG

 #define CUMEM_FAULT(cc, reason) asm("mov"#cc" r0, #%a0 " : : "i" (reason)); \

                                 asm("b"#cc" " CSM_ZN2KL5PanicENS_13TKernLibPanicE)	

 #endif

 __NAKED__ void kumemget_no_paging_assert(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne memcpy ");				// if not, just do memcpy

 #ifndef USE_REPLACEMENT_UMEMGET

 	asm("b umemget_no_paging_assert");

 #else

 	asm("b umemget");

 #endif

 	}

 #ifndef USE_REPLACEMENT_UMEMGET

 #ifdef __CPU_ARMV6

 // Conditional returns are not predicted on ARMv6

 __NAKED__ void dummy_umemget32_exit()

 	{

 	asm("_umemget32_exit: ");

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

 	}

 #define UMEMGET32_EXIT(cc)	asm("b"#cc" _umemget32_exit")

 #else

 #define UMEMGET32_EXIT(cc)	asm("ldm"#cc"fd sp!, {r4, pc}")

 #endif

 EXPORT_C __NAKED__ void kumemget32(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne wordmove ");			// if not, just do wordmove

 	// otherwise fall through to umemget32

 	}

 EXPORT_C __NAKED__ void umemget32(TAny* /*aKernAddr*/, const TAny* /*aUserAddr*/, TInt /*aLength*/)

 	{

 	ASM_ASSERT_PAGING_SAFE

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	asm("subs r12, r2, #1");

 	asm("ldrhsb r11, [r0]");				// test access to first byte of kernel memory

 	asm("ldrhsb r11, [r0,r12]");			// test access to last byte of kernel memory

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 #ifdef _DEBUG

 	asm("tst r2, #3 ");						// check length is a whole number of words

 	CUMEM_FAULT(ne, KL::EWordMoveLengthNotMultipleOf4);

 #endif

 	PLD(1);

 	asm("_umemget_word_aligned: ");	

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

 	asm("subs ip, r2, #32 ");

 	asm("blo _umemget32_small_copy ");

 	PLD_ioff(1, 32);

 	asm("beq _umemget32_32_byte_case ");	// 32 byte case is common - don't bother to align

 	asm("rsb lr, r0, #32 ");				// align destination: 0 - 28 byte copy

 	asm("movs lr, lr, lsl #27 ");

 	asm("beq _umemget32_large_copy ");

 	asm("sub r2, r2, lr, lsr #27 ");

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

 	asm("ldrmit r3, [r1], #4 ");

 	asm("ldrmit r4, [r1], #4 ");

 	asm("ldrmit ip, [r1], #4 ");

 	asm("ldrmit lr, [r1], #4 ");

 	asm("stmmiia r0!, {r3, r4, ip, lr} ");

 	asm("ldreqt r3, [r1], #4 ");

 	asm("ldreqt r4, [r1], #4 ");

 	asm("ldrcst ip, [r1], #4 ");

 	asm("stmeqia r0!, {r3, r4} ");

 	asm("strcs ip, [r0], #4 ");

 	asm("subs ip, r2, #32 ");

 	asm("blo _umemget32_small_copy ");

 	asm("_umemget32_large_copy: ");			// copy 32 byte blocks

 	PLD_ioff(1, 64);

 	asm("_umemget32_32_byte_case: ");

 	asm("ldrt r2, [r1], #4 ");

 	asm("ldrt r3, [r1], #4 ");

 	asm("ldrt r4, [r1], #4 ");

 	asm("ldrt lr, [r1], #4 ");

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

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

 	asm("ldrt r2, [r1], #4 ");

 	asm("ldrt r3, [r1], #4 ");

 	asm("ldrt r4, [r1], #4 ");

 	asm("ldrt lr, [r1], #4 ");

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

 	asm("bhs _umemget32_large_copy ");

 	asm("_umemget32_small_copy: ");			// 0 - 31 byte copy, length in ip bits 0-4

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

 	UMEMGET32_EXIT(eq);

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

 	asm("ldrmit r3, [r1], #4 ");

 	asm("ldrmit r4, [r1], #4 ");

 	asm("ldrmit ip, [r1], #4 ");

 	asm("ldrmit lr, [r1], #4 ");

 	asm("stmmiia r0!, {r3, r4, ip, lr} ");

 	asm("ldreqt r3, [r1], #4 ");

 	asm("ldreqt r4, [r1], #4 ");

 	asm("ldrcst ip, [r1], #4 ");

 	asm("stmeqia r0!, {r3, r4} ");

 	asm("strcs ip, [r0], #4 ");	

 	asm("movs r2, r2, lsl #3 ");

 	UMEMGET32_EXIT(eq);

 	asm("msr cpsr_f, r2 ");					// put length bits 1, 0 into N, Z	

 	asm("ldrmibt r3, [r1], #1 ");

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

 	asm("ldreqbt ip, [r1], #1 ");

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

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

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

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

 	}

 EXPORT_C __NAKED__ void kumemget(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne memcpy ");				// if not, just do memcpy

 	// otherwise fall through to umemget

 	}

 EXPORT_C __NAKED__ void umemget(TAny* /*aKernAddr*/, const TAny* /*aUserAddr*/, TInt /*aLength*/)

 	{

 	// Optimised for aligned transfers, as unaligned are very rare in practice

 	ASM_ASSERT_PAGING_SAFE

 	asm("umemget_no_paging_assert:");

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	asm("subs r12, r2, #1");

 	asm("ldrhsb r11, [r0]");				// test access to first byte of kernel memory

 	asm("ldrhsb r11, [r0,r12]");			// test access to last byte of kernel memory

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 	PLD(1);

 	asm("tst r0, #3 ");

 	asm("tsteq r1, #3 ");

 	asm("beq _umemget_word_aligned ");

 	asm("cmp r2, #8 ");

 	asm("bhs 1f ");

 	asm("2: ");

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

  	asm("ldrplbt r3, [r1], #1 ");

 	asm("strplb r3, [r0], #1 ");

 	asm("bgt 2b ");

 	__JUMP(,lr);

 	asm("1: ");						// Attempt to word align

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

 	asm("beq 5f ");

 	asm("rsbs r3, r3, #0 ");		// 01->c0000000 (MI,VC) 10->80000000 (MI,VS) 11->40000000 (PL,VC)

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

 	asm("ldrmibt r3, [r1], #1 ");

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

 	asm("ldrmibt r3, [r1], #1 ");

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

 	asm("ldrvcbt r3, [r1], #1 ");

 	asm("strvcb r3, [r0], #1 ");	// r0 now word aligned

 	asm("5: ");

 	asm("movs r3, r1, lsl #31 ");

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

 	asm("bcs 3f ");					// branch if src mod 4 = 2 or 3

 	asm("bpl _umemget_word_aligned ");	// branch if src mod 4 = 0

 	asm("4: ");						// src mod 4 = 1

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #8 ");

 	asm("orrge r3, r3, ip, lsl #24 ");

 	asm("strge r3, [r0], #4 ");

 	asm("bgt 4b ");

 	asm("add r1, r1, #1 ");

 	asm("b umemget_do_end ");

 	asm("3: ");						

 	asm("bmi 5f ");

 	asm("2: ");						// src mod 4 = 2

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #16 ");

 	asm("orrge r3, r3, ip, lsl #16 ");

 	asm("strge r3, [r0], #4 ");

 	asm("bgt 2b ");

 	asm("add r1, r1, #2 ");

 	asm("b umemget_do_end ");

 	asm("5: ");						// src mod 4 = 3

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #24 ");

 	asm("orrge r3, r3, ip, lsl #8 ");

 	asm("strge r3, [r0], #4 ");

 	asm("bgt 5b ");

 	asm("add r1, r1, #3 ");

 	asm("umemget_do_end: ");

 	__JUMP(eq,lr);

 	asm("adds r2, r2, #2 ");		// -1 if 1 left, 0 if 2 left, +1 if 3 left

 	asm("ldrplbt r3, [r1], #1 ");

 	asm("strplb r3, [r0], #1 ");

 	asm("ldrplbt r3, [r1], #1 ");

 	asm("strplb r3, [r0], #1 ");

 	asm("ldrnebt r3, [r1], #1 ");

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

 	__JUMP(,lr);

 	}

 #endif  // USE_REPLACEMENT_UMEMGET

 __NAKED__ void kumemput_no_paging_assert(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne memcpy ");				// if not, just do memcpy

 #ifndef USE_REPLACEMENT_UMEMPUT

 	asm("b umemput_no_paging_assert");

 #else

 	asm("b umemput");

 #endif

 	}

 #ifndef USE_REPLACEMENT_UMEMPUT

 #ifdef __CPU_ARMV6

 // Conditional returns are not predicted on ARMv6

 __NAKED__ void dummy_umemput32_exit()

 	{

 	asm("_umemput32_exit: ");

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

 	}

 #define UMEMPUT32_EXIT(cc)	asm("b"#cc" _umemput32_exit")

 #else

 #define UMEMPUT32_EXIT(cc)	asm("ldm"#cc"fd sp!, {r4, pc}")

 #endif

 EXPORT_C __NAKED__ void kumemput32(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne wordmove ");			// if not, just do wordmove

 	// otherwise fall through to umemput32

 	}

 EXPORT_C __NAKED__ void umemput32(TAny* /*aUserAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)

 	{

 	ASM_ASSERT_DATA_PAGING_SAFE

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	asm("subs r12, r2, #1");

 	asm("ldrhsb r11, [r1]");				// test access to first byte of kernel memory

 	asm("ldrhsb r11, [r1,r12]");			// test access to last byte of kernel memory

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 #ifdef _DEBUG

 	asm("tst r2, #3 ");						// check length is a whole number of words

 	CUMEM_FAULT(ne, KL::EWordMoveLengthNotMultipleOf4);

 #endif

 	PLD(1);

 	asm("cmp r2, #4 ");						// special case for 4 byte copy which is common

 	asm("ldrhs r3, [r1], #4 ");

 	asm("subhs r2, r2, #4 ");

 	asm("strhst r3, [r0], #4 ");

 	__JUMP(ls,lr);

 	asm("_umemput_word_aligned: ");

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

 	asm("subs r2, r2, #32 ");

 	asm("bhs _umemput32_align_source ");

 	asm("_umemput32_small_copy: ");			// copy 1 - 31 bytes

 	asm("mov r2, r2, lsl #27 ");

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

 	asm("ldmmiia r1!, {r3, r4, ip, lr} ");

 	asm("strmit r3, [r0], #4 ");

 	asm("strmit r4, [r0], #4 ");

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

 	asm("strmit ip, [r0], #4 ");

 	asm("ldrcs ip, [r1], #4 ");

 	asm("strmit lr, [r0], #4 ");

 	asm("streqt r3, [r0], #4 ");

 	asm("streqt r4, [r0], #4 ");

 	asm("strcst ip, [r0], #4 ");

 	asm("movs r2, r2, lsl #3 ");

 	UMEMPUT32_EXIT(eq);

 	asm("msr cpsr_f, r2 ");					// put length bits 1, 0 into N, Z

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

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

 	asm("strmibt r3, [r0], #1 ");

 	asm("movmi r3, r3, lsr #8 ");

 	asm("strmibt r3, [r0], #1 ");

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

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

 	asm("_umemput32_align_source: ");

 	PLD_ioff(1, 32);

 	asm("cmp r2, #32 ");

 	asm("bls _umemput32_large_copy ");		// don't bother if length <= 64

 	asm("rsb ip, r1, #32 ");

 	asm("movs ip, ip, lsl #27 ");

 	asm("beq _umemput32_large_copy ");

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

 	asm("sub r2, r2, ip, lsr #27 ");

 	asm("ldmmiia r1!, {r3, r4, ip, lr} ");

 	asm("strmit r3, [r0], #4 ");

 	asm("strmit r4, [r0], #4 ");

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

 	asm("strmit ip, [r0], #4 ");

 	asm("ldrcs ip, [r1], #4 ");

 	asm("strmit lr, [r0], #4 ");

 	asm("streqt r3, [r0], #4 ");

 	asm("streqt r4, [r0], #4 ");

 	asm("strcst ip, [r0], #4 ");

 	asm("_umemput32_large_copy: ");			// copy 32 byte blocks

 	PLD_ioff(1, 64);

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

 	asm("strt r3, [r0], #4 ");

 	asm("strt r4, [r0], #4 ");

 	asm("strt ip, [r0], #4 ");

 	asm("strt lr, [r0], #4 ");

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

 	asm("strt r3, [r0], #4 ");

 	asm("strt r4, [r0], #4 ");

 	asm("strt ip, [r0], #4 ");

 	asm("strt lr, [r0], #4 ");

 	asm("subs r2, r2, #32 ");

 	asm("bhs _umemput32_large_copy ");

 	asm("adds r2, r2, #32 ");

 	asm("bne _umemput32_small_copy ");

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

 	}

 __NAKED__ void uumemcpy32(TAny* /*aUserDst*/, const TAny* /*aUserSrc*/, TInt /*aLength*/)

 	{

 	ASM_ASSERT_PAGING_SAFE

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 	asm("1: ");

 	asm("subs r2, r2, #4 ");

 	asm("ldrplt r3, [r1], #4 ");

 	asm("strplt r3, [r0], #4 ");

 	asm("bpl 1b ");

 	__JUMP(,lr);

 	}

 __NAKED__ void uumemcpy(TAny* /*aUserDst*/, const TAny* /*aUserSrc*/, TInt /*aLength*/)

 	{

 	ASM_ASSERT_PAGING_SAFE

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 	asm("cmp r2, #8 ");

 	asm("bcs 1f ");

 	asm("2: ");

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

 	asm("ldrplbt r3, [r1], #1 ");

 	asm("strplbt r3, [r0], #1 ");

 	asm("bgt 2b ");

 	__JUMP(,lr);

 	asm("1: ");

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

 	asm("beq 5f ");

 	asm("rsbs r3, r3, #0 ");		// 01->c0000000 (MI,VC) 10->80000000 (MI,VS) 11->40000000 (PL,VC)

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

 	asm("ldrmibt r3, [r1], #1 ");

 	asm("strmibt r3, [r0], #1 ");

 	asm("ldrmibt r3, [r1], #1 ");

 	asm("strmibt r3, [r0], #1 ");

 	asm("ldrvcbt r3, [r1], #1 ");

 	asm("strvcbt r3, [r0], #1 ");	// r0 now word aligned

 	asm("5: ");

 	asm("movs r3, r1, lsl #31 ");

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

 	asm("bcs 3f ");					// branch if src mod 4 = 2 or 3

 	asm("bmi 4f ");					// branch if src mod 4 = 1

 	asm("2: ");

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 2b ");

 	asm("uumemcpy_do_end: ");

 	__JUMP(eq,lr);

 	asm("adds r2, r2, #2 ");		// -1 if 1 left, 0 if 2 left, +1 if 3 left

 	asm("ldrplbt r3, [r1], #1 ");

 	asm("strplbt r3, [r0], #1 ");

 	asm("ldrplbt r3, [r1], #1 ");

 	asm("strplbt r3, [r0], #1 ");

 	asm("ldrnebt r3, [r1], #1 ");

 	asm("strnebt r3, [r0], #1 ");

 	__JUMP(,lr);

 	asm("3: ");						// get here if src mod 4 = 2 or 3

 	asm("bmi 5f ");					// branch if 3

 	asm("2: ");

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #16 ");

 	asm("orrge r3, r3, ip, lsl #16 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 2b ");

 	asm("add r1, r1, #2 ");

 	asm("b uumemcpy_do_end ");

 	asm("5: ");

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #24 ");

 	asm("orrge r3, r3, ip, lsl #8 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 5b ");

 	asm("add r1, r1, #3 ");

 	asm("b uumemcpy_do_end ");

 	asm("4: ");

 	asm("subs r2, r2, #4 ");

 	asm("ldrget r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #8 ");

 	asm("orrge r3, r3, ip, lsl #24 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 4b ");

 	asm("add r1, r1, #1 ");

 	asm("b uumemcpy_do_end ");

 	}

 EXPORT_C __NAKED__ void kumemput(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne memcpy ");				// if not, just do memcpy

 	// otherwise fall through to umemput

 	}

 EXPORT_C __NAKED__ void umemput(TAny* /*aUserAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)

 	{

 	// Optimised for word-aligned transfers, as unaligned are very rare in practice	

 	ASM_ASSERT_DATA_PAGING_SAFE

 	asm("umemput_no_paging_assert:");

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	asm("subs r12, r2, #1");

 	asm("ldrhsb r11, [r1]");				// test access to first byte of kernel memory

 	asm("ldrhsb r11, [r1,r12]");			// test access to last byte of kernel memory

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 	PLD(1);

 	asm("tst r0, #3 ");

 	asm("tsteq r1, #3 ");

 	asm("beq _umemput_word_aligned ");

 	asm("cmp r2, #8 ");

 	asm("bcs 1f ");

 	asm("2: ");						// Copy 0 - 7 bytes

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

 	asm("ldrplb r3, [r1], #1 ");

 	asm("strplbt r3, [r0], #1 ");

 	asm("bgt 2b ");

 	__JUMP(,lr);

 	asm("1: ");						// Word-align dest

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

 	asm("beq 5f ");

 	asm("rsbs r3, r3, #0 ");		// 01->c0000000 (MI,VC) 10->80000000 (MI,VS) 11->40000000 (PL,VC)

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

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

 	asm("strmibt r3, [r0], #1 ");

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

 	asm("strmibt r3, [r0], #1 ");

 	asm("ldrvcb r3, [r1], #1 ");

 	asm("strvcbt r3, [r0], #1 ");	// r0 now word aligned

 	asm("5: ");

 	asm("movs r3, r1, lsl #31 ");

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

 	asm("bcs 3f ");					// branch if src mod 4 = 2 or 3

 	asm("bpl _umemput_word_aligned "); // branch if src mod 4 = 0

 	asm("4: ");						// get here if src mod 4 = 1

 	asm("subs r2, r2, #4 ");

 	asm("ldrge r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #8 ");

 	asm("orrge r3, r3, ip, lsl #24 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 4b ");

 	asm("add r1, r1, #1 ");

 	asm("b _umemput_do_end ");

 	asm("3: ");						// get here if src mod 4 = 2 or 3

 	asm("bmi 5f ");					// branch if 3

 	asm("2: ");

 	asm("subs r2, r2, #4 ");

 	asm("ldrge r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #16 ");

 	asm("orrge r3, r3, ip, lsl #16 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 2b ");

 	asm("add r1, r1, #2 ");

 	asm("b _umemput_do_end ");

 	asm("5: ");						// get here if src mod 4 = 3

 	asm("subs r2, r2, #4 ");

 	asm("ldrge r3, [r1], #4 ");

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

 	asm("movge r3, r3, lsr #24 ");

 	asm("orrge r3, r3, ip, lsl #8 ");

 	asm("strget r3, [r0], #4 ");

 	asm("bgt 5b ");

 	asm("add r1, r1, #3 ");

 	asm("_umemput_do_end: ");		// z set if done, else r2 == length remaining - 4

 	__JUMP(eq,lr);

 	asm("adds r2, r2, #2 ");		// r2 = -1 if 1 left, 0 if 2 left, +1 if 3 left

 	asm("ldrplb r3, [r1], #1 ");

 	asm("strplbt r3, [r0], #1 ");

 	asm("ldrplb r3, [r1], #1 ");

 	asm("strplbt r3, [r0], #1 ");

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

 	asm("strnebt r3, [r0], #1 ");

 	__JUMP(,lr);

 	}

 #endif  // USE_REPLACEMENT_UMEMPUT

 EXPORT_C __NAKED__ void kumemset(TAny* /*aAddr*/, const TUint8 /*aValue*/, TInt /*aLength*/)

 	{

 	asm("mrs r3, spsr ");			// r3=spsr_svc

 	asm("tst r3, #0x0f ");			// test for user mode

 	asm("bne memset ");				// if not, just do memset

 	// otherwise fall through to umemset

 	}

 EXPORT_C __NAKED__ void umemset(TAny* /*aUserAddr*/, const TUint8 /*aValue*/, TInt /*aLength*/)

 	{

 	ASM_ASSERT_DATA_PAGING_SAFE

 #ifdef __USER_MEMORY_GUARDS_ENABLED__

 	// Wrap the workings of this function in an internal call, so we can save/restore UMG state

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

 	USER_MEMORY_GUARD_OFF(,r11,r12);		// leaves UMG mode in r11

 	asm("bl 0f");							// call to label below

 	USER_MEMORY_GUARD_RESTORE(r11,r12);

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

 	asm("0:");

 #endif

 	asm("cmp r2, #7 ");

 	asm("bhi 2f ");

 	asm("1: ");

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

 	asm("strplbt r1, [r0], #1 ");

 	asm("bgt 1b ");

 	__JUMP(,lr);	

 	asm("2: ");

 	asm("and r1, r1, #0xff ");

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

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

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

 	asm("beq 3f ");

 	asm("rsbs r3, r3, #0 ");		// 01->c0000000 (MI,VC) 10->80000000 (MI,VS) 11->40000000 (PL,VC)

 	asm("strmibt r1, [r0], #1 ");	// if 01 or 10 do 2 byte stores

 	asm("strmibt r1, [r0], #1 ");

 	asm("strvcbt r1, [r0], #1 ");	// if 01 or 11 do 1 byte store

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

 	asm("3: ");						// r0 now word aligned

 	asm("subs r2, r2, #4 ");

 	asm("strplt r1, [r0], #4 ");

 	asm("bgt 3b ");

 	__JUMP(eq,lr);					// return if finished

 	asm("adds r2, r2, #2 ");		// -1 if 1 left, 0 if 2 left, +1 if 3 left

 	asm("strplbt r1, [r0], #1 ");

 	asm("strplbt r1, [r0], #1 ");

 	asm("strnebt r1, [r0], #1 ");

 	__JUMP(,lr);

 	}

 }