// 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\memmodel\epoc\moving\arm\xsched.cia

 // 

 //

 #include <e32cia.h>

 #include <arm_mem.h>

 #define iMState		iWaitLink.iSpare1

 //#define __DEBUG_BAD_ADDR

 #define iCurrentVMProcess				iExtras[0]

 #define	iCurrentDataSectionProcess		iExtras[1]

 #define	iCompleteDataSectionProcess		iExtras[2]

 #ifdef __REQUEST_COMPLETE_MACHINE_CODED__

 #if defined(_DEBUG)

 extern "C" void __DebugMsgRequestComplete(TInt a0, TInt a1, TInt a2);

 extern "C" void __DebugMsgReqCompleteWrite(TInt a0, TInt a1, TInt a2);

 #endif

 __NAKED__ void DThread::RequestComplete(TRequestStatus*& /*aStatus*/, TInt /*aReason*/)

 //

 // Signal this threads request semaphore.

 // Enter with system locked, return with system unlocked.

 //

 	{

 	ASM_DEBUG2(DThreadRequestComplete,r0,lr);

 	asm("ldr r3, [r1] ");					// r3 points to TRequestStatus

 	asm("mov r12, #0 ");

 	asm("str r12, [r1] ");					// aStatus=NULL

 	asm(".global _asm_RequestComplete ");

 	asm("_asm_RequestComplete: ");

 #ifdef BTRACE_REQUESTS

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

 	asm("mov r1,r3");

 	asm("mov r3,r2");											// arg3 = aReason

 	asm("mov r2,r1");											// arg2 = aStatus

 	asm("add r1,r0,#%a0" : : "i" _FOFF(DThread,iNThread));		// arg1 = &this->iNThread

 	asm("ldr r0,_threadReqequestCompleteTraceHeader");			// arg0 = header

 	asm("bl " CSM_ZN6BTrace4OutXEmmmm);

 	asm("ldmia sp!,{r0-r3,lr}");

 #endif

 	ASM_DEBUG3(RequestComplete,r0,r3,r2);

 	asm("ldrb r12, [r0, #%a0]" : : "i" _FOFF(DThread,iMState));

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

 	asm("add r6, r0, #%a0" : : "i" _FOFF(DThread,iNThread));

 	asm("ldr r0, [r0, #%a0]" : : "i" _FOFF(DThread,iOwningProcess));

 	asm("cmp r12, #%a0" : : "i" (DThread::EDead));	// test if iMState=EDead

 	asm("ldr r12, [r0, #%a0]!" : : "i" _FOFF(DMemModelProcess, iNumChunks));	// step r0 on to iChunks[0]

 	asm("beq req_complete_dead_thread ");	// if it is, finished

 	asm("b req_complete_2");

 	// lookup r3 in address space of process r0

 	asm("req_complete_1: ");

 	asm("ldmcsib r0!, {r1,r4} ");			// r1=data section base, r4=chunk ptr

 	asm("subcss r1, r3, r1 ");				// r1=offset

 	asm("ldrcs r5, [r4, #%a0]" : : "i" _FOFF(DChunk,iMaxSize));	// if offset>=0, r5=chunk max size

 	asm("cmpcs r1, r5 ");					// and compare offset to max size

 	asm("addcs r0, r0, #4 ");				// if offset>=max size, move to next entry

 	asm("req_complete_2: ");

  	asm("subcss r12, r12, #1 ");			// and decrement counter

 	asm("bcs req_complete_1 ");				// loop if more chunks to check

 	asm("cmp r12, #0 ");					// did we find chunk?

 	asm("ldrge r3, [r4, #%a0]" : : "i" _FOFF(DMemModelChunk,iHomeRegionOffset));

 	asm("ldrge r5, [r4, #%a0]" : : "i" _FOFF(DMemModelChunk,iHomeRegionSize));

 	asm("cmpge r1, r3 ");					// if we did but offset<iHomeRegionOffset, no good

 	asm("blt req_complete_invalid ");		// or if we didn't find it, no good

 	asm("add r3, r3, r5 ");					// r3=home region offset+home region size

 	asm("cmp r1, r3 ");						// if offset >= iHomeRegionOffset+iHomeRegionSize, no good

 	asm("ldrlt r0, [r4, #%a0]" : : "i" _FOFF(DChunk,iBase));	// if OK, r0=chunk base

 	asm("bge req_complete_invalid ");

 											// Zero flag always clear here

 	ASM_DEBUG3(ReqCompleteWrite,r0,r1,r2);

 	asm(".global __magic_address_reqc ");

 	asm("__magic_address_reqc: ");			// this instruction is magically immune from exceptions

 	asm("str r2, [r0, r1] ");				// r0+r1=current address, store completion code

 	asm("movne r0, r6 ");					// if write OK, r0->iNThread

 	asm("ldmnefd sp!, {r4-r6} ");			// restore registers

 	asm("movne r1, #0 ");

 	asm("bne  " CSM_ZN5NKern19ThreadRequestSignalEP7NThreadP10NFastMutex);

 #ifndef __DEBUG_BAD_ADDR

 	asm("req_complete_invalid: ");

 	asm("ldmfd sp!, {r4-r6} ");				// restore registers

 	asm("b  " CSM_ZN5NKern12UnlockSystemEv);

 #endif

 #ifdef __DEBUG_BAD_ADDR

 	asm("req_complete_invalid: ");			//DEBUG

 	asm("mov r9, #0xde000000 ");

 	asm("str r9, [r9, #0xaf] ");			//HACK-CRASH SYSTEM

 #endif

 	asm("req_complete_dead_thread: ");

 	asm("ldmfd sp!, {r4-r6} ");				// restore registers

 	asm("b  " CSM_ZN5NKern12UnlockSystemEv);

 #ifdef BTRACE_REQUESTS

 	asm("_threadReqequestCompleteTraceHeader:");

 	asm(".word %a0" : : "i" (BTRACE_HEADER_C(16,BTrace::ERequests,BTrace::ERequestComplete)));

 #endif

 	}

 #endif

 #ifdef __SCHEDULER_MACHINE_CODED__

 #if defined(_DEBUG)

 extern "C" void __DebugMsgFixedAddress();

 extern "C" void __DebugMsgMoving();

 extern "C" void __DebugMsgProtectChunks(int aProc);

 extern "C" void __DebugMsgUnprotectChunks(int aProc);

 extern "C" void __DebugMsgMoveChunksToHome(int aProc);

 extern "C" void __DebugMsgMoveChunksToData(int aProc);

 extern "C" void __DebugMsgMoveChunkToHomeAddress(int aChunk);

 extern "C" void __DebugMsgProtectChunk(int aChunk);

 extern "C" void __DebugMsgMoveChunkToRunAddress(int aChunk, int aRunAddr);

 extern "C" void __DebugMsgUnprotectChunk(int aChunk);

 #endif

 GLDEF_C __NAKED__ void DoProcessSwitch()

 	{

 	//

 	// Enter and return in mode_svc with system lock held, kernel unlocked, interrupts enabled.

 	// On entry r0->scheduler, r2->current thread, r5->current address space, r9->new address space

 	// Must preserve r0,r2, can modify other registers

 	//

 	asm("mrc p15, 0, r7, c3, c0, 0 ");		// r7=DACR

 	asm("ldr r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("mov r1, r9 ");

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

 	asm("orr r7, r7, #0x30 ");				// unlock page tables

 	asm("mcr p15, 0, r7, c3, c0, 0 ");		// set DACR

 	CPWAIT(,ip);

 	asm("ldr lr, [r9, #%a0]" : : "i" _FOFF(DArmPlatProcess,iAttributes));

 	asm("mov ip, #0 ");

 	asm("cmp r4, #0 ");

 	asm("ldrne ip, [r4, #%a0]" : : "i" _FOFF(DArmPlatProcess,iAttributes));

 	// register contents at this point are:

 	// r0->TheScheduler, r1->new process, r2->new thread, r3=scratch, r4=current VM process

 	// r5=scratch, r7-11 scratch, r12=current VM process attributes,

 	// r14=new process attributes

 	asm("ands r6, lr, #%a0" : : "i" ((TInt)DMemModelProcess::EMoving));

 	asm("beq resched_fixed ");				// skip if new process is fixed

 	// The current process has moving chunks

 	ASM_DEBUG0(Moving)

 #ifdef __CPU_WRITE_BACK_CACHE

 	// We need to flush the DCache before moving anything.

 	// Condition for flush here is

 	// NEW PROCESS MOVING && (NEW PROCESS!=COMPLETE DATA SECTION PROCESS)

 	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));	// r3=complete data section process

 	asm("cmp r3, r1 ");						// check if TheCurrentProcess==TheCompleteDataSectionProcess

 	asm("blne SyncMapChangeAttempt ");		// if not same, flush the DCache; on return ZF=0 means abort

 											// stack alignment OK since called function is assembler

 	asm("bne end_process_switch ");			// if contention, just exit now

 #endif

 	asm("mov r6, #0 ");

 	asm("str r6, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));

 	// if (pD && pD!=pP) ...

 	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));		// r3=current data section process

 	asm("mov r8, #0 ");

 	asm("str r8, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));

 	asm("cmp r3, #0 ");						// if !TheCurrentDataSectionProcess

 	asm("cmpne r3, r1 ");					// || TheCurrentDataSectionProcess==TheCurrentProcess

 	asm("beq resched_moving1 ");			// skip next section

 	// Move TheCurrentDataSectionProcess to the home section and protect it

 	ASM_DEBUG1(MoveChunksToHome,r3)

 	asm("ldr r5, [r3, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

 	asm("cmp r5, #0 ");						// check if current data section process has no chunks

 	asm("beq resched_moving1b ");			// skip if it does

 	asm("stmfd sp!, {r1-r4,r12} ");

 	asm("add r4, r3, #%a0" : : "i" (_FOFF(DMemModelProcess,iChunks)+4));

 	asm("resched_moving1a: ");

 	asm("ldr r7, [r4], #12 ");				// r7=address of chunk to move

 	asm("bl MoveHomeOrProtectChunk ");		// move chunk - this must preserve r0

 	asm("ldr ip, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

 	asm("cmp ip, #0 ");						// check for contention

 	asm("bne abort_resched_mh ");			// if there is, abort

 #ifdef BTRACE_FAST_MUTEX

 	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

 	asm("cmp ip, #0");

 	asm("ldrne r2, [sp, #4]"); // current thread

 	asm("blne procswitch_trace_flash");

 #endif

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

 	asm("bne resched_moving1a ");

 	asm("ldmfd sp!, {r1-r4,r12} ");

 	asm("resched_moving1b: ");

 	asm("cmp r3, r4 ");

 	asm("moveq r4, #0 ");					// ... TheCurrentVMProcess=NULL

 	asm("streq r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("mov r3, #0 ");						// TheCurrentDataSectionProcess=NULL

 	asm("str r3, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));

 	// if (pV && pV!=pP)

 	asm("resched_moving1: ");

 	asm("cmp r4, #0 ");						// if !TheCurrentVMProcess

 	asm("cmpne r4, r1 ");					// || TheCurrentVMProcess==TheCurrentProcess

 	asm("beq resched_moving2 ");			// skip next section

 	// Protect TheCurrentVMProcess but don't move it

 	// register contents at this point are:

 	// r0->TheScheduler, r2->new thread, r1->TheCurrentProcess, r4=current VM process

 	// r12=current VM process attributes, r3,r5,r7-r11->scratch

 	ASM_DEBUG1(ProtectChunks,r4)

 	asm("tst r12, #%a0" : : "i" (DMemModelProcess::EVariableAccess));	// r12=TheCurrentVMProcess->iAttributes

 	asm("beq resched_moving2 ");			// if fixed access process, nothing to do

 	asm("ldr r5, [r4, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

 	asm("cmp r5, #0 ");

 	asm("beq resched_moving2b ");			// if number of chunks=0, nothing to do

 	asm("add r11, r4, #%a0" : : "i" (_FOFF(DMemModelProcess,iChunks)+4));

 	asm("resched_moving2a: ");

 	asm("ldr r7, [r11], #12 ");				// r7=address of chunk to protect

 	asm("bl ProtectChunk ");				// protect it

 	asm("ldr r7, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

 	asm("cmp r7, #0 ");						// check for contention

 	asm("bne abort_resched_mp ");			// if there is, abort

 #ifdef BTRACE_FAST_MUTEX

 	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

 	asm("cmp ip, #0");

 	asm("blne procswitch_trace_flash");

 #endif

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

 	asm("bne resched_moving2a ");

 	asm("resched_moving2b: ");

 	asm("mov r4, #0 ");						// TheCurrentVMProcess=NULL

 	asm("str r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("resched_moving2: ");

 	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));

 	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	// Unprotect the TheCurrentProcess and move it to the data section if necessary

 	// register contents at this point are:

 	// r0->TheScheduler, r2->new thread, r1->TheCurrentProcess

 	// r12=current VM process attributes, r3,r5,r7-r11->scratch

 	ASM_DEBUG1(MoveChunksToData,r1)

 	asm("ldr r5, [r1, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

 	asm("cmp r5, #0 ");

 	asm("beq resched_finish ");				// if number of chunks=0, nothing to do

 	asm("stmfd sp!, {r1-r2,r12} ");			// don't need r3 or r4 any more

 	asm("add r4, r1, #%a0" : : "i" _FOFF(DMemModelProcess,iChunks));

 	asm("resched_moving3a: ");

 	asm("ldmia r4!, {r7,r8,r9} ");			// r7=run address, r8=ptr to chunk, r9 top 16bits=isReadOnly

 	asm("bl MoveRunOrUnprotectChunk ");		// move chunk to data section and/or unprotect it

 	asm("ldr ip, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

 	asm("cmp ip, #0 ");						// check for contention

 	asm("bne abort_resched_mr ");			// if there is, abort

 #ifdef BTRACE_FAST_MUTEX

 	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

 	asm("cmp ip, #0");

 	asm("blne procswitch_trace_flash");

 #endif

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

 	asm("bne resched_moving3a ");

 	asm("ldmfd sp!, {r1-r2,r12} ");

 	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));

 	asm("b resched_finish ");

 	// The current process has no moving chunks

 	asm("resched_fixed: ");

 	ASM_DEBUG0(FixedAddress)

 	asm("str r6, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));

 	asm("cmp r4, #0	");						// if TheCurrentVMProcess==NULL

 	asm("beq resched_fixed1 ");				// skip this section

 	// Protect TheCurrentVMProcess

 	ASM_DEBUG1(ProtectChunks,r4)

 	asm("ldr r5, [r4, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

 	asm("add r11, r4, #%a0" : : "i" (_FOFF(DMemModelProcess,iChunks)+4));

 	asm("cmp r5, #0 ");

 	asm("beq resched_fixed1b ");			// if number of chunks=0, nothing to do

 	asm("resched_fixed1a: ");

 	asm("ldr r7, [r11], #12 ");				// r7=address of chunk to protect

 	asm("bl ProtectChunk ");				// protect it

 	asm("ldr r7, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

 	asm("cmp r7, #0 ");						// check for contention

 	asm("bne abort_resched_fp ");			// if there is, abort

 #ifdef BTRACE_FAST_MUTEX

 	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

 	asm("cmp ip, #0");

 	asm("blne procswitch_trace_flash");

 #endif

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

 	asm("bne resched_fixed1a ");

 	asm("resched_fixed1b: ");

 	asm("mov r4, #0 ");						// TheCurrentVMProcess=NULL

 	asm("str r4, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("resched_fixed1: ");

 	// Unprotect TheCurrentProcess

 	ASM_DEBUG1(UnprotectChunks,r1)

 	asm("ldr r5, [r1, #%a0]" : : "i" _FOFF(DMemModelProcess,iNumChunks));

 	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("cmp r5, #0 ");

 	asm("beq resched_finish ");				// if number of chunks=0, nothing to do

 	asm("add r11, r1, #%a0" : : "i" _FOFF(DMemModelProcess,iChunks));

 	asm("resched_fixed2a: ");

 	asm("ldmia r11!, {r7,r8,r9} ");			// r7=run address, r8=ptr to chunk, r9 top 16bits=isReadOnly

 	asm("bl UnprotectChunk ");				// unprotect chunk

 	asm("ldr r7, [r0, #%a0]" : : "i" _FOFF(TScheduler,iLock.iWaiting));

 	asm("cmp r7, #0 ");						// check for contention

 	asm("bne abort_resched_fu ");			// if there is, abort

 #ifdef BTRACE_FAST_MUTEX

 	asm("ldrb ip, [r0, #%a0]" : : "i" (_FOFF(TScheduler,iFastMutexFilter)));

 	asm("cmp ip, #0");

 	asm("blne procswitch_trace_flash");

 #endif

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

 	asm("bne resched_fixed2a ");

 	asm("resched_finish: ");

 	asm("str r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));	// iAddressSpace=new process

 	asm("resched_flush: ");

 #ifdef __CPU_SPLIT_TLB

 	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDPermChg));

 	asm("mov r1, #0 ");

 	FLUSH_DTLB(ne,r1);

 	asm("tst r6, #%a0" : : "i" (Mmu::EFlushIPermChg));

 	FLUSH_ITLB(ne,r1);

 #else

 	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDPermChg|Mmu::EFlushIPermChg));

 	asm("mov r1, #0 ");

 	FLUSH_IDTLB(ne,r1);

 #endif

 #ifdef __CPU_WRITE_BACK_CACHE

 //#ifdef __CPU_SPLIT_CACHE

 	// D cache flush already done

 //	asm("tst r6, #%a0" : : "i" (Mmu::EFlushIMove));	Should never need to flush ICache during context switch

 //	FLUSH_ICACHE(ne,r1);

 //#endif

 #else

 #ifdef __CPU_SPLIT_CACHE

 	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDMove));

 	FLUSH_DCACHE(ne,r1);

 //	asm("tst r6, #%a0" : : "i" (Mmu::EFlushIMove));	Should never need to flush ICache during context switch

 //	FLUSH_ICACHE(ne,r1);

 #else

 	asm("tst r6, #%a0" : : "i" (Mmu::EFlushDMove|Mmu::EFlushIMove));

 	FLUSH_IDCACHE(ne,r1);

 #endif

 #endif

 	asm("cmp r6, #0 ");						// any page table changes?

 	DRAIN_WRITE_BUFFER(ne,r1,r7);			// if so, make sure page table changes take effect

 	asm("end_process_switch: ");

 	asm("ldmia sp!, {r7,lr} ");

 	asm("mcr p15, 0, r7, c3, c0 ");			// restore DACR

 	CPWAIT(,r3);

 	__JUMP(,lr);

 	asm("abort_resched_mh: ");				// Reschedule aborted during MoveToHome

 	asm("ldmfd sp!, {r1-r4,r12} ");

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

 	asm("bne resched_flush ");				// if MoveToHome incomplete skip

 	asm("cmp r3, r4 ");						// if TheCurrentDataSectionProcess==TheCurrentVMProcess ...

 	asm("streq r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));	// ... TheCurrentVMProcess=NULL

 	asm("str r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentDataSectionProcess));	// TheCurrentDataSectionProcess=NULL

 	asm("b resched_flush ");				//

 	asm("abort_resched_mp: ");				// Reschedule aborted during protect before moving

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

 	asm("streq r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("b resched_flush ");				//

 	asm("abort_resched_mr: ");				// Reschedule aborted during MoveToRunAddress

 	asm("ldmfd sp!, {r1-r2,r12} ");

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

 	asm("streq r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCompleteDataSectionProcess));

 	asm("b resched_flush ");				//

 	asm("abort_resched_fp: ");				// Reschedule aborted during protect before fixed

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

 	asm("streq r5, [r0, #%a0]" : : "i" _FOFF(TScheduler,iCurrentVMProcess));

 	asm("b resched_flush ");				//

 	asm("abort_resched_fu: ");				// Reschedule aborted during unprotect

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

 	asm("streq r1, [r0, #%a0]" : : "i" _FOFF(TScheduler,iAddressSpace));	// iAddressSpace=new process

 	asm("b resched_flush ");				//

 	//

 	// Subroutines

 	//

 	// MoveHomeOrProtectChunk

 	// If a chunk is movable and not at its home address, move it to the home address;

 	// if the chunk is variable-access and not protected, protect it

 	// r7 points to chunk

 	// modifies r1-r3 and r8-r12

 	asm("MoveHomeOrProtectChunk: ");

 	asm("ldr r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

 	asm("tst r10, #%a0" : : "i" (DMemModelChunk::EFixedAddress));

 	asm("bne ProtectChunk1 ");

 	asm("ldr r11, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iHomeBase));	// r11=home base

 	asm("ldr r12, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// r12=iBase

 	asm("cmp r11, r12 ");

 	asm("beq ProtectChunk1 ");			// already at home address

 	ASM_DEBUG1(MoveChunkToHomeAddress,r7)

 	asm("str r11, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// iBase=iHomeBase

 	asm("add r8, r7, #%a0" : : "i" _FOFF(DMemModelChunk,iNumPdes));

 	asm("ldmia r8, {r8-r10} ");	// r8=numpdes r9=base pdes, r10=home pdes

 	asm("cmp r8, #0 ");

 	asm("str r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

 	asm("beq MoveHome0 ");

 	asm("ldr r12, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdePermissions[0]));

 	asm("mov r1, #0 ");

 	asm("str r1, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ENotRunning

 	asm("MoveHome1: ");

 	asm("ldr r3, [r9] ");				// fetch old pde

 	asm("str r1, [r9], #4 ");			// clear old pde

 	asm("bics r3, r3, #0x3fc ");		// mask out permissions and check for not present PDE

 	asm("orrne r3, r3, r12 ");			// if present, or in new permissions

 	asm("moveq r3, #0 ");				// else zero entry

 	asm("str r3, [r10], #4 ");			// put into new pde

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

 	asm("bne MoveHome1 ");				// loop to do next PDE

 	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDMove|Mmu::EFlushDPermChg));	// moving chunk can't contain code

 	__JUMP(,lr);

 	asm("MoveHome0: ");

 	asm("str r8, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ENotRunning

 	__JUMP(,lr);

 	// ProtectChunk

 	// Protect a chunk - r7 points to chunk

 	// r8-r10,r12 modified

 	asm("ProtectChunk: ");

 	asm("ldr r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

 	asm("ProtectChunk1: ");

 	asm("tst r10, #%a0" : : "i" (DMemModelChunk::EFixedAccess));

 	asm("ldreq r12, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));

 	__JUMP(ne,lr);

 	asm("cmp r12, #0 ");

 	__JUMP(eq,lr);						// if already in non-running state, nothing to do

 	asm("ldr r8, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iNumPdes));	// r8=number of chunk pdes

 	asm("ldr r9, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));	// r9=pde address

 	ASM_DEBUG1(ProtectChunk,r7)

 	asm("cmp r8, #0 ");

 	asm("beq ProtectChunk0 ");

 	asm("tst r10, #%a0" : : "i" (DMemModelChunk::ECode));		// check if chunk contains code

 	asm("orrne r6, r6, #%a0" : : "i" (Mmu::EFlushIPermChg));	// if it does, may need to flush ITLB

 	asm("ldr r10, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdePermissions[0]));	//r10=new permissions

 	asm("ProtectChunk2: ");

 	asm("ldr r12, [r9] ");				// fetch old pde

 	asm("bics r12, r12, #0x3fc ");		// mask out permissions and check for not present PDE

 	asm("orrne r12, r12, r10 ");		// if present, or in new permissions

 	asm("moveq r12, #0 ");				// else zero pde

 	asm("str r12, [r9], #4 ");			// replace pde

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

 	asm("bne ProtectChunk2 ");			// loop for next PDE

 	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDPermChg));

 	asm("ProtectChunk0: ");

 	asm("str r8, [r7, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ENotRunning

 	__JUMP(,lr);

 	// MoveRunOrUnprotectChunk

 	// If a chunk is movable and not at its run address in this process, move it to the run address;

 	// if the chunk is variable-access and not unprotected, unprotect it.

 	// r7=run address, r8 points to chunk

 	// ignore read-only flag since the ARM cannot support it

 	// r1-r3, r7, r9-r12 modified, r8 unmodified

 	asm("MoveRunOrUnprotectChunk: ");

 	asm("mov r9, #2 ");					// r9=state of chunk

 	asm("MoveToRunAddress: ");

 	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

 	asm("tst r12, #%a0" : : "i" (DMemModelChunk::EFixedAddress));

 	asm("bne UnprotectChunk1 ");

 	asm("ldr r11, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// r11=old base

 	asm("cmp r11, r7 ");				// check if already at run address

 	asm("beq UnprotectChunk1 ");		// if it is, just unprotect it

 	ASM_DEBUG2(MoveChunkToRunAddress,r8,r7)

 	asm("str r7, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iBase));	// iBase=run address

 	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iNumPdes));

 	asm("str r9, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// store new chunk state

 	asm("cmp r12, #0 ");

 	asm("beq MoveRun0 ");

 	asm("ldr r10, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

 	asm("mov r1, #0 ");

 	asm("add r7, r10, r7, lsr #18 ");	// r7=iPdes+(new address/2^18)

 	asm("sub r7, r7, r11, lsr #18 ");	// r7=iPdes+(new address-old address)/2^18

 	asm("str r7, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

 	asm("add r9, r8, r9, lsl #2 ");

 	asm("ldr r9, [r9, #%a0]" : : "i" (_FOFF(DMemModelChunk,iPdePermissions[0])));	// r9=PDE permissions to use

 	asm("MoveRun1: ");

 	asm("ldr r3, [r10] ");				// fetch old pde

 	asm("str r1, [r10], #4 ");			// clear old pde

 	asm("bics r3, r3, #0x3fc ");		// mask out permissions and check for not present PDE

 	asm("orrne r3, r3, r9 ");			// if present, or in new permissions

 	asm("moveq r3, #0 ");				// else clear pde

 	asm("str r3, [r7], #4 ");			// put into new pde

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

 	asm("bne MoveRun1 ");

 	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDMove|Mmu::EFlushDPermChg));	// moving chunk can't contain code

 	asm("MoveRun0: ");

 	__JUMP(,lr);

 	// UnprotectChunk

 	// Apply running permissions to a chunk

 	// r8 points to chunk

 	// ignore read-only flag since the ARM cannot support it

 	// r7,r9,r10,r12 modified, r8,r11 unmodified

 	asm("UnprotectChunk: ");

 	asm("mov r9, #2 ");					// r9=new state of chunk

 	asm("ApplyTopLevelPermissions: ");

 	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iAttributes));

 	asm("UnprotectChunk1: ");

 	asm("tst r12, #%a0" : : "i" (DMemModelChunk::EFixedAccess));

 	asm("ldreq r10, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// r10=old chunk state

 	__JUMP(ne,lr);

 	asm("cmp r10, r9 ");

 	__JUMP(eq,lr);						// if state already correct, nothing to do

 	asm("ldr r10, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iNumPdes));

 	ASM_DEBUG1(UnprotectChunk,r8)

 	asm("str r9, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iChunkState));	// iChunkState=ERunningRW

 	asm("cmp r10, #0 ");

 	asm("beq UnprotectChunk0 ");

 	asm("tst r12, #%a0" : : "i" (DMemModelChunk::ECode));		// check if chunk contains code

 	asm("orrne r6, r6, #%a0" : : "i" (Mmu::EFlushIPermChg));	// if it does, may need to flush ITLB

 	asm("ldr r12, [r8, #%a0]" : : "i" _FOFF(DMemModelChunk,iPdes));

 	asm("add r9, r8, r9, lsl #2 ");

 	asm("ldr r9, [r9, #%a0]" : : "i" (_FOFF(DMemModelChunk,iPdePermissions[0])));	//r9=new permissions

 	asm("UnprotectChunk2: ");

 	asm("ldr r7, [r12] ");				// fetch old pde

 	asm("bics r7, r7, #0x3fc ");		// mask out permissions and check for not present PDE

 	asm("orrne r7, r7, r9 ");			// if present, or in new permissions

 	asm("moveq r7, #0 ");				// else clear pde

 	asm("str r7, [r12], #4 ");			// replace pde

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

 	asm("bne UnprotectChunk2 ");

 	asm("orr r6, r6, #%a0" : : "i" (Mmu::EFlushDPermChg));

 	asm("UnprotectChunk0: ");

 	__JUMP(,lr);

 #ifdef BTRACE_FAST_MUTEX

 	// expects scheduler in r0, current thread in r2, preserves all but r10

 	asm("procswitch_trace_flash:");

 	asm("mov r10, sp");

 	asm("bic sp, sp, #7"); 					// align stack to 8 bytes

 	asm("stmdb sp!,{r3,ip}");

 	asm("stmdb sp!,{r0,r1,r2,lr}");		// 4th item on stack is PC value for trace

 	asm("mov r1, r0");

 	asm("ldr r0, procswitch_trace_header"); // header parameter in r0

 	asm("add r3, r1, #%a0" : : "i" _FOFF(TScheduler,iLock)); // fast mutex parameter in r3

 	asm("mov lr, pc");

 	asm("ldr pc, [r1, #%a0]" : : "i" _FOFF(TScheduler,iBTraceHandler));	

 	asm("ldmia sp!,{r0,r1,r2,lr}");

 	asm("ldmia sp!,{r3,ip}");

 	asm("mov sp, r10");					// put stack back

 	__JUMP(,lr);

 	asm("procswitch_trace_header:");

 	asm(".word %a0" : : "i" ((TInt)(16<<BTrace::ESizeIndex) + ((BTrace::EContextIdPresent|BTrace::EPcPresent) << BTrace::EFlagsIndex*8) + (BTrace::EFastMutex<< BTrace::ECategoryIndex*8) + (BTrace::EFastMutexFlash << BTrace::ESubCategoryIndex*8)) );

 #endif

 	// Global data references

 	asm("__TheScheduler: ");

 	asm(".word TheScheduler ");

 	asm("__TheMmu: ");

 	asm(".word %a0" : : "i" ((TInt)&::TheMmu));

 	};

 __NAKED__ TUint32 DMemModelChunk::ApplyTopLevelPermissions(TChunkState /*aChunkState*/)

 	{

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

 	asm("mov r8, r0 ");		// r8 = chunk ptr

 	asm("mov r9, r1 ");		// r9 = chunk state

 	asm("mrc p15, 0, r3, c3, c0, 0 ");	// r3=DACR

 	asm("mov r6, #0 ");

 	asm("orr r1, r3, #0x30 ");

 	asm("mcr p15, 0, r1, c3, c0, 0 ");	// unlock page tables

 	CPWAIT(,lr);

 	asm("bl ApplyTopLevelPermissions ");

 	asm("mcr p15, 0, r3, c3, c0, 0 ");	// lock page tables

 	asm("mov r0, r6 ");					// return flush flags

 	DRAIN_WRITE_BUFFER(,r1,r1);

 	CPWAIT(,r1);

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

 	}

 __NAKED__ TUint32 DMemModelChunk::MoveToRunAddress(TLinAddr /*aLinAddr*/, TChunkState /*aChunkState*/)

 	{

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

 	asm("mov r8, r0 ");		// r8 = chunk ptr

 	asm("mov r7, r1 ");		// r7 = run address

 	asm("mrc p15, 0, r5, c3, c0, 0 ");	// r5=DACR

 	asm("mov r9, r2 ");		// r9 = chunk state

 	asm("mov r6, #0 ");

 	asm("orr r1, r5, #0x30 ");

 	asm("mcr p15, 0, r1, c3, c0, 0 ");	// unlock page tables

 	CPWAIT(,lr);

 	asm("bl MoveToRunAddress ");

 	asm("mcr p15, 0, r5, c3, c0, 0 ");	// lock page tables

 	asm("mov r0, r6 ");					// return flush flags

 	DRAIN_WRITE_BUFFER(,r1,r1);

 	CPWAIT(,r1);

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

 	}

 __NAKED__ TUint32 DMemModelChunk::MoveToHomeSection()

 	{

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

 	asm("mov r7, r0 ");		// r7 = chunk ptr

 	asm("mrc p15, 0, r0, c3, c0, 0 ");	// r0=DACR

 	asm("mov r6, #0 ");

 	asm("orr r1, r0, #0x30 ");

 	asm("mcr p15, 0, r1, c3, c0, 0 ");	// unlock page tables

 	CPWAIT(,lr);

 	asm("bl MoveHomeOrProtectChunk ");

 	asm("mcr p15, 0, r0, c3, c0, 0 ");	// lock page tables

 	asm("mov r0, r6 ");					// return flush flags

 	DRAIN_WRITE_BUFFER(,r1,r1);

 	CPWAIT(,r1);

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

 	}

 #endif