// 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\euser\epoc\arm\uc_utl.cia
// 
//

#include <e32cia.h>
#include <u32std.h>
#include <e32base.h>
#include <e32rom.h>
#include <e32svr.h>
#include <e32hashtab.h>
#include <u32exec.h>
#include "uc_std.h"


#if defined(__MEM_MACHINE_CODED__)
EXPORT_C __NAKED__ void Mem::Swap(TAny* /*aPtr1*/, TAny* /*aPtr2*/, TInt /*aLength*/)
/**
Swaps a number of bytes of data between two specified locations.

The source and target areas can overlap.

@param aPtr1   A pointer to the first location taking part in the swap. 
@param aPtr2   A pointer to second location taking part in the swap. 
@param aLength The number of bytes to be swapped between the two locations. 
               This value must not be negative.

@panic USER 94 In debug builds only, if aLength is negative.
*/
    {

    asm("   cmp      r0,r1");
    asm("   cmpne    r2,#0");
	__JUMP(eq,lr);
//
// Test for same alignment, if more than 16 bytes to swap
//
    asm("   and      r3,r0,#3");
    asm("   and      ip,r1,#3");
    asm("   cmp      r2,#16");
    asm("   addlt    r3,r3,#4");
    asm("   cmp      r3,ip");
    asm("   beq      same_aligned_swap");

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

    asm("swap_loop:");

    asm("   ldrb     r3,[r0]");
    asm("   ldrb     r4,[r1]");
    asm("   strb     r3,[r1],#1");
    asm("   strb     r4,[r0],#1");
    asm("   subs     r2,r2,#1");
	asm("beq swap_exit1 ");

    asm("   ldrb     r3,[r0]");
    asm("   ldrb     r4,[r1]");
    asm("   strb     r3,[r1],#1");
    asm("   strb     r4,[r0],#1");
    asm("   subs     r2,r2,#1");
	asm("beq swap_exit1 ");

    asm("   ldrb     r3,[r0]");
    asm("   ldrb     r4,[r1]");
    asm("   strb     r3,[r1],#1");
    asm("   strb     r4,[r0],#1");
    asm("   subs     r2,r2,#1");
	asm("beq swap_exit1 ");

    asm("   ldrb     r3,[r0]");
    asm("   ldrb     r4,[r1]");
    asm("   strb     r3,[r1],#1");
    asm("   strb     r4,[r0],#1");
    asm("   subs     r2,r2,#1");
    asm("   bne      swap_loop");
	asm("swap_exit1: ");
	__POPRET("r4,");

    asm("same_aligned_swap:");

    asm("   stmfd    sp!,{r4-r10,lr}");
//
// r3 contains the byte offset from word alignment, 0,1,2 or 3
// subtract 1 to get -1,0,1 or 2, and if -1 make it 3
// that gives us 0,1,2 or 3 if the alignment is 3,2,1 or 0 respectively
// We can use that to jump directly to the appropriate place for
// swapping the relevent number of bytes to achieve word alignment
// r4 is set to 3-r3 to correct the length for the number of bytes
// swapped
//
    asm("   subs     r3,r3,#1");
    asm("   movmi    r3,#3");
    asm("   rsb      r4,r3,#3");
    asm("   sub      r2,r2,r4");
	asm("   add      pc,pc,r3,asl #4");
	asm("	nop ");	// never executed
//
// Jumps here if 3 bytes to swap before word aligned
//
    asm("   ldrb     r4,[r0]");
    asm("   ldrb     ip,[r1]");
    asm("   strb     r4,[r1],#1");
    asm("   strb     ip,[r0],#1");
//
// Jumps here if 2 bytes to swap before word aligned
//
    asm("   ldrb     r4,[r0]");
    asm("   ldrb     ip,[r1]");
    asm("   strb     r4,[r1],#1");
    asm("   strb     ip,[r0],#1");
//
// Jumps here if 1 byte to swap before word aligned
//
    asm("   ldrb     r4,[r0]");
    asm("   ldrb     ip,[r1]");
    asm("   strb     r4,[r1],#1");
    asm("   strb     ip,[r0],#1");
//
// We are now word aligned. Fast swapping, here we come...
//
    asm("word_aligned_swap:");
    asm("   movs     ip,r2,lsr #6"); // Number of 64 blocks to swap
    asm("   beq      its_smaller_swap");

    asm("swap_64_bytes:");
    asm("   ldmia    r1,{r3-r6}");
    asm("   ldmia    r0,{r7-r10}");
    asm("   stmia    r1!,{r7-r10}");
    asm("   stmia    r0!,{r3-r6}");
    asm("   ldmia    r1,{r3-r6}");
    asm("   ldmia    r0,{r7-r10}");
    asm("   stmia    r1!,{r7-r10}");
    asm("   stmia    r0!,{r3-r6}");
    asm("   ldmia    r1,{r3-r6}");
    asm("   ldmia    r0,{r7-r10}");
    asm("   stmia    r1!,{r7-r10}");
    asm("   stmia    r0!,{r3-r6}");
    asm("   ldmia    r1,{r3-r6}");
    asm("   ldmia    r0,{r7-r10}");
    asm("   stmia    r1!,{r7-r10}");
    asm("   stmia    r0!,{r3-r6}");
    asm("   subs     ip,ip,#1");
    asm("   bne      swap_64_bytes");
//
// Less than 64 bytes to go...
//
    asm("its_smaller_swap:");
    asm("   ands     r2,r2,#63");
	asm("beq swap_exit2 ");
    asm("   cmp      r2,#4");
    asm("   blt      finish_swap");
    asm("final_swap_loop:");
    asm("   ldr      r3,[r1]");
    asm("   ldr      ip,[r0]");
    asm("   str      r3,[r0],#4");
    asm("   str      ip,[r1],#4");
    asm("   subs     r2,r2,#4");
    asm("   cmp      r2,#4");
    asm("   bge      final_swap_loop");
//
// Less than 4 bytes to go...
//
    asm("finish_swap:");
    asm("   tst      r2,#2");
    asm("   ldrneb   r3,[r0]");
    asm("   ldrneb   ip,[r1]");
    asm("   strneb   r3,[r1],#1");
    asm("   strneb   ip,[r0],#1");
    asm("   ldrneb   r3,[r0]");
    asm("   ldrneb   ip,[r1]");
    asm("   strneb   r3,[r1],#1");
    asm("   strneb   ip,[r0],#1");

    asm("   tst      r2,#1");
    asm("   ldrneb   r3,[r0]");
    asm("   ldrneb   ip,[r1]");
    asm("   strneb   r3,[r1],#1");
    asm("   strneb   ip,[r0],#1");

	asm("swap_exit2: ");
	__POPRET("r4-r10,");
    }
#endif

#ifdef __REGIONS_MACHINE_CODED__

__NAKED__ GLDEF_C void AllocAnotherRect( TRegion * /*aRegion*/ )
	{
	// Returns with Z flag set to indicate error
	
	asm("ldr r1, [r0, #4] ");			// r1=iError
	asm("cmp r1, #0 ");
	asm("bne return_error ");
	asm("ldr r1, [r0, #8] ");			// r1=iAllocedRects
	asm("ldr r12, [r0] ");				// r12=iCount
	asm("tst r1, #0x40000000 ");		// test ERRegionBuf
	asm("beq allocanother1 ");			// don't branch if TRegionFix
	asm("cmn r1, r12 ");				// test if iCount==-iAllocedRects
	__JUMP(ne,lr);
	asm("b  " CSM_ZN7TRegion10ForceErrorEv);		// if so, ForceError()
	asm("allocanother1: ");
	asm("cmp r1, #0 ");
	asm("bpl allocanother3 ");			// branch if RRegion, continue if RRegionBuf
	asm("orr r2, r1, #0x40000000 ");	// r2=iAllocedRects|ERRegionBuf
	asm("cmn r2, r12 ");				// check if iCount==(-(iAllocedRects|ERRegionBuf))
	__JUMP(ne,lr);
	asm("ldr r2, [r0, #12] ");			// r2=iGranularity
	asm("add r1, r12, r2 ");			// iAllocedRects=iCount+iGranularity - change into RRegion
	asm("str r1, [r0, #8] ");
	asm("stmfd sp!, {r0,r1,r12,lr} ");	// save registers used in function call
	asm("mov r0, r1, lsl #4 ");			// number of bytes to allocate
	asm("bl  " CSM_ZN4User5AllocEi);			// User::Alloc
	asm("movs r2, r0 ");				// returned pointer into r2
	asm("ldmfd sp!, {r0,r1,r12,lr} ");	// restore registers
	asm("add r3, r0, #20 ");			// r3=address of first rectangle
	asm("str r2, [r0, #16] ");			// iRectangleList=returned pointer
	asm("beq  " CSM_ZN7TRegion10ForceErrorEv);	// if pointer null, ForceError()
	asm("cmp r12, #0 ");
	asm("beq return_success ");
	asm("stmfd sp!, {r4,r5} ");
	asm("allocanother2: ");
	asm("ldmia r3!, {r0,r1,r4,r5} ");	// copy data to new area
	asm("subs r12, r12, #1 ");
	asm("stmia r2!, {r0,r1,r4,r5} ");
	asm("bne allocanother2 ");
	asm("ldmfd sp!, {r4,r5} ");
	asm("return_success: ");
	asm("movs r0, #1 ");				// clear Z flag to indicate success
	__JUMP(,lr);
	asm("allocanother3: ");				// come here if RRegion
	asm("cmp r1, r12 ");				// check if iCount==iAllocedRects
	__JUMP(ne,lr);
	asm("ldr r2, [r0, #12] ");			// r2 = iGranularity
	asm("add r1, r1, r2 ");				// iAllocedRects+=iGranularity
	asm("str r1, [r0, #8] ");
	asm("stmfd sp!, {r0,lr} ");			// preserve r0,lr across function call
	asm("ldr r0, [r0, #16] ");			// r0=address of current cell
	asm("mov r1, r1, lsl #4 ");			// r1=number of bytes to allocate
	asm("mov r2, #0 ");
	asm("bl  " CSM_ZN4User7ReAllocEPvii);		// User::ReAlloc
	asm("movs r2, r0 ");				// returned pointer into r2
	asm("ldmfd sp!, {r0,lr} ");			// restore r0,lr
	asm("strne r2, [r0, #16] ");		// if returned ptr not null, iRectangleList=returned ptr
	__JUMP(ne,lr);
	asm("b  " CSM_ZN7TRegion10ForceErrorEv);		// else ForceError()
	}


__NAKED__ EXPORT_C void TRegion::ForceError()
	{
	// Returns with Z flag set to indicate error
	
	asm("stmfd sp!, {r0,lr} ");
	asm("bl " CSM_ZN7TRegion5ClearEv);	// Clear()
	asm("ldmfd sp!, {r0,lr} ");			// restore r0,lr
	asm("mov r1, #1 ");
	asm("str r1, [r0, #4] ");			// iError=ETrue
	asm("return_error: ");
	asm("movs r0, #0 ");				// set Z flag to indicate error
	__JUMP(,lr);
	}



__NAKED__ EXPORT_C TRect TRegion::BoundingRect() const
/**
Gets the minimal rectangle that bounds the entire region.

@return The region's minimal bounding rectangle.
*/
	{
	asm("ldr r2, [r1] ");			// r2=iCount
	asm("cmp r2, #0 ");				// list empty?
	asm("beq boundingrect0 ");		// branch if empty
	asm("ldr r3, [r1, #8] ");			// if not empty, r3 points to first rectangle
	asm("stmfd sp!, {r4-r8,lr} ");
	asm("cmn r3, r3 ");
	asm("ldrcc r3, [r1, #16] ");		// if RRegion
	asm("addcs r3, r1, #20 ");			// RRegionBuf
	asm("submi r3, r3, #8 ");			// TRegionFix
	asm("ldmia r3!, {r4-r7} ");			// if not empty bounds = first rectangle
	asm("b boundingrect2 ");			// if not empty go and check rest of list
	asm("boundingrect1: ");
	asm("ldmia r3!, {r1,r8,r12,lr} ");	// fetch next rectangle
	asm("cmp r1, r4 ");					// if next.iTl.iX<bounds.iTl.iX
	asm("movlt r4, r1 ");				//		bounds.iTl.iX=next.iTl.iX
	asm("cmp r8, r5 ");					// if next.iTl.iY<bounds.iTl.iY
	asm("movlt r5, r8 ");				//		bounds.iTl.iY=next.iTl.iY
	asm("cmp r12, r6 ");				// if next.iBr.iX>bounds.iBr.iX
	asm("movgt r6, r12 ");				//		bounds.iBr.iX=next.iBr.iX
	asm("cmp lr, r7 ");					// if next.iBr.iY>bounds.iBr.iY
	asm("movgt r7, lr ");				//		bounds.iBr.iY=next.iBr.iY
	asm("boundingrect2: ");
	asm("subs r2, r2, #1 ");			// decrement count
	asm("bne boundingrect1 ");			// repeat for all rectangles
	asm("stmia r0, {r4-r7} ");			// store result
	__POPRET("r4-r8,");

	asm("boundingrect0: ");
	asm("mov r1, #0 ");					// if list empty, bounds = 0,0,0,0
	asm("mov r3, #0 ");
	asm("mov r12, #0 ");
	asm("stmia r0, {r1,r2,r3,r12} ");	// store result
	__JUMP(,lr);
	}




__NAKED__ EXPORT_C TBool TRegion::IsContainedBy(const TRect & /*aRect*/) const
/**
Tests whether the region is fully enclosed within the specified rectangle.

@param aRect The specified rectangle.
 
@return True, if the region is fully enclosed within the rectangle (their sides 
        may touch); false, otherwise.
*/
	{
	asm("ldr r12, [r0, #8] ");			// r12 points to first rectangle
	asm("stmfd sp!, {r4-r7,lr} ");	
	asm("cmn r12, r12 ");
	asm("ldrcc r12, [r0, #16] ");		// if RRegion
	asm("addcs r12, r0, #20 ");			// RRegionBuf
	asm("submi r12, r12, #8 ");			// TRegionFix

	asm("ldr r0, [r0] ");				// r0=iCount
	asm("ldmia r1, {r4-r7} ");			// aRect coordinates into r4-r7
	
	asm("subs r0, r0, #1 ");			// decrement it
	asm("bmi iscontainedby2 ");			// if iCount was zero, return TRUE
	
	asm("iscontainedby1: ");
	asm("ldmia r12!, {r1,r2,r3,lr} ");	// coordinates of next rectangle
	asm("cmp r1, r4 ");					// compare next.iTl.iX with aRect.iTl.iX
	asm("cmpge r2, r5 ");				// if >=, compare next.iTl.iY with aRect.iTl.iY
	asm("cmpge r6, r3 ");				// if >=, compare aRect.Br.iX with next.iBr.iX
	asm("cmpge r7, lr ");				// if >=, compare aRect.Br.iY with next.iBr.iY
	asm("subges r0, r0, #1 ");			// if >=, next is contained in aRect, so iterate
	asm("bge iscontainedby1 ");			// will drop through if r0<0 or if next exceeds aRect
	asm("iscontainedby2: ");
	asm("mov r0, r0, lsr #31 ");		// return 1 if r0<0, 0 if r0>=0
	__POPRET("r4-r7,");
	}




__NAKED__ EXPORT_C void TRegion::Copy(const TRegion & /*aRegion*/)
/**
Copies another region to this region.

The state of the specified region's error flag is also copied.

@param aRegion The region to be copied.
*/
	{
	asm("ldr r2, [r1, #4] ");					// r2 = aRegion.iError
	asm("cmp r2, #0 ");
	asm("bne  " CSM_ZN7TRegion10ForceErrorEv);	// if (aRegion.iError) ForceError();
	asm("ldr r2, [r1] ");						// r1 = aRegion.iCount
	asm("cmp r2, #0 ");
	asm("beq " CSM_ZN7TRegion5ClearEv);			// region to copy is empty so simply clear our buffer
	asm("stmfd sp!, {r0,r1,r4,r5,r6,lr} ");		// preserve r0,r1,lr across function calls
	asm("mov r4, r1 ");
	asm("mov r5, r0 ");
	asm("ldr r2, [r0, #4] ");					// r2 = iError
	asm("cmp r2, #0 ");
	asm("blne  " CSM_ZN7TRegion5ClearEv);		// if (iError) Clear();
	asm("mov r0, r5 ");
	asm("ldr r1, [r4] ");						// r1 = aRegion.iCount, r0 = this
	asm("bl	 " CSM_ZN7TRegion11SetListSizeEi);	// SetListSize(aRegion.iCount);
	asm("cmp r0, #0 ");
	asm("beq copyregion_end ");
	asm("ldr r3, [r4] ");						// r3 = aRegion.iCount
	asm("cmp r3, #0 ");
	asm("str r3, [r5] ");						// iCount=aRegion.iCount
	asm("beq copyregion_end ");
	asm("ldr r0, [r5, #8] ");					// r0 points to first rectangle
	asm("cmn r0, r0 ");
	asm("ldrcc r0, [r5, #16] ");				// if RRegion
	asm("addcs r0, r5, #20 ");					// RRegionBuf
	asm("submi r0, r0, #8 ");					// TRegionFix
	asm("ldr r1, [r4, #8] ");					// r1 points to first rectangle
	asm("cmn r1, r1 ");
	asm("ldrcc r1, [r4, #16] ");				// if RRegion
	asm("addcs r1, r4, #20 ");					// RRegionBuf
	asm("submi r1, r1, #8 ");					// TRegionFix
	asm("copyregion1: ");
	asm("ldmia r1!, {r2,r4,r5,r12} ");			// copy aRegion.iRectangleList to iRectangleList
	asm("subs r3, r3, #1 ");
	asm("stmia r0!, {r2,r4,r5,r12} ");
	asm("bne copyregion1 ");

	asm("copyregion_end: ");
	__POPRET("r0,r1,r4,r5,r6,");
	}




__NAKED__ EXPORT_C void TRegion::Offset(const TPoint & /*anOffset*/)
/**
Moves the region by adding a TPoint offset to the co-ordinates of its corners.
	
The size of the region is not changed.
	
@param aOffset The offset by which the region is moved. The region is moved 
               horizontally by aOffset.iX pixels and vertically by aOffset.iY pixels.
*/
	{
	asm("ldmia r1, {r1,r2} ");		// r1=anOffset.iX, r2=anOffset.iY
	// fall through...
	}




__NAKED__ EXPORT_C void TRegion::Offset(TInt /*xOffset*/,TInt /*yOffset*/)
/**
Moves the region by adding X and Y offsets to the co-ordinates of its corners.
	
The size of the region is not changed.
	
@param aXoffset The number of pixels by which to move the region horizontally. 
                If negative, the region moves leftwards. 
@param aYoffset The number of pixels by which to move the region vertically. 
                If negative, the region moves upwards.
*/
	{
	asm("ldr r12, [r0] ");			// r12=iCount
	asm("cmp r12, #0 ");
	__JUMP(eq,lr);
	asm("ldr r3, [r0, #8] ");		// r0 points to first rectangle
	asm("cmn r3, r3 ");
	asm("ldrcc r0, [r0, #16] ");	// if RRegion
	asm("addcs r0, r0, #20 ");		// RRegionBuf
	asm("submi r0, r0, #8 ");		// TRegionFix
	asm("stmfd sp!, {r4,r5,lr} ");
	asm("offsetregion2: ");
	asm("ldmia r0, {r3-r5,lr} ");	// r3-r5,lr = next rectangle coordinates
	asm("subs r12, r12, #1 ");
	asm("add r3, r3, r1 ");			// Tl.iX += anOffset.iX
	asm("add r4, r4, r2 ");			// Tl.iY += anOffset.iY
	asm("add r5, r5, r1 ");			// Br.iX += anOffset.iX
	asm("add lr, lr, r2 ");			// Br.iY += anOffset.iY
	asm("stmia r0!, {r3-r5,lr} ");	// store new coordinates
	asm("bne offsetregion2 ");
	__POPRET("r4,r5,");
	}




__NAKED__ EXPORT_C TBool TRegion::Contains(const TPoint & /*aPoint*/) const
/**
Tests whether a point is located within the region.

If the point is located on the top or left hand side of any rectangle in the 
region, it is considered to be within that rectangle and within the region. 

If the point is located on the right hand side or bottom of a rectangle, it 
is considered to be outside that rectangle, and may be outside the region.

@param aPoint The specified point. 

@return True, if the point is within the region; false, otherwise.
*/
	{
	asm("ldr r12, [r0] ");			// r12 = iCount
	asm("stmfd sp!, {r4,r5,lr} ");
	asm("cmp r12, #0 ");
	asm("beq contains0 ");			// if iCount=0, return FALSE
	asm("ldr r3, [r0, #8] ");		// r0 points to first rectangle
	asm("cmn r3, r3 ");
	asm("ldrcc r0, [r0, #16] ");	// if RRegion
	asm("addcs r0, r0, #20 ");		// RRegionBuf
	asm("submi r0, r0, #8 ");		// TRegionFix
	asm("ldmia r1, {r1, r2} ");		// r1=aPoint.iX, r2=aPoint.iY
	asm("contains1: ");
	asm("ldmia r0!, {r3-r5,lr} ");	// coordinates of next rectangle into r3-r5,lr
	asm("cmp r3, r1 ");				// compare next.iTl.iX with aPoint.iX
	asm("cmple r4, r2 ");			// if <=, compare next.iTl.iY with aPoint.iY
	asm("bgt contains2 ");			// if >, aPoint is not contained in rectangle, so iterate
	asm("cmp r1, r5 ");				// compare aPoint.iX with next.iBr.iX
	asm("cmplt r2, lr ");			// if <, compare aPoint.iY with next.iBr.iY
	asm("contains2: ");
	asm("subges r12, r12, #1 ");	// if >=, aPoint is not contained in rect, so iterate
	asm("bgt contains1 ");
	asm("cmp r12, #0 ");
	asm("movne r0, #1 ");			// if r12 non-zero, return TRUE else FALSE
	asm("contains0: ");
	asm("moveq r0, #0 ");
	__POPRET("r4,r5,");
	}




__NAKED__ EXPORT_C TBool TRegion::Intersects(const TRect &/*aRect*/) const
/**
Tests whether where there is any intersection between this region and the specified rectangle.

@param aRect The specified rectangle.
 
@return True, if there is an intersection; false, otherwise.
*/
	{
	asm("ldr    r12, [r0] ");		// r12 = iCount
	asm("stmfd  sp!, {r4-r7,lr} ");
	asm("cmp    r12, #0 ");
	asm("beq    intersects0 ");		// if iCount=0, return FALSE
	asm("ldr    lr, [r0, #8] ");	// r0 points to first rectangle	
	asm("ldmia  r1, {r1-r4} ");		// (load aRect into r1 - r4)
	asm("cmn    lr, lr ");
	asm("ldrcc  r0, [r0, #16] ");	// if RRegion
	asm("addcs  r0, r0, #20 ");		// RRegionBuf
	asm("submi  r0, r0, #8 ");		// TRegionFix
	asm("cmp    r1, r3 ");			// check if aRect is empty
	asm("cmplt  r2, r4 ");
	asm("bge    intersects0 ");
	
	asm("intersects1: ");
	asm("ldmia  r0!, {r5-r7,lr} ");	// coordinates of next rectangle into r5-r7,lr	
	asm("cmp    r1, r7 ");			// check if they intersect
	asm("cmplt  r2, lr ");
	asm("cmplt  r5, r3 ");
	asm("cmplt  r6, r4 ");
	asm("subges r12, r12, #1 ");	// if not then decrement and loop
	asm("bgt    intersects1 ");
	
	asm("intersects0: ");
	asm("movge  r0, #0 ");
	asm("movlt  r0, #1 ");
	__POPRET("r4-r7,");
	}




__NAKED__ void TRegion::DeleteRect(TRect * /*aRect*/)
//
// Delete a specific rectangle in the list.
//
	{
	asm("ldr r12, [r0] ");			// r12=iCount
	asm("ldr r3, [r0, #8] ");		// r0 points to first rectangle
	asm("subs r12, r12, #1 ");		// decrement it
	asm("str r12, [r0] ");			// iCount--;
	asm("cmn r3, r3 ");
	asm("ldrcc r0, [r0, #16] ");	// if RRegion
	asm("addcs r0, r0, #20 ");		// RRegionBuf
	asm("submi r0, r0, #8 ");		// TRegionFix
	asm("sub r2, r1, r0 ");			// r2=offset of aRect from iRectangleList
	asm("subs r12, r12, r2, lsr #4 ");	// r12 now equals number of rectangles requiring moving
	__JUMP(eq,lr);
	asm("add r0, r1, #16 ");			// r0 = aRect+1
	asm("stmfd sp!, {r4,lr} ");
	asm("deleterect1: ");
	asm("ldmia r0!, {r2-r4,lr} ");		// move rectangles following aRect back by one place
	asm("subs r12, r12, #1 ");
	asm("stmia r1!, {r2-r4,lr} ");
	asm("bne deleterect1 ");
	__POPRET("r4,");
	}




__NAKED__ EXPORT_C void TRegion::ClipRect(const TRect & /*aRect*/)
/**
Clips the region to the specified rectangle.

The resulting region is the area of overlap between the region and the rectangle. 
If there is no overlap, all rectangles within this region are deleted and 
the resulting region is empty.

@param aRect The rectangle to which this region is to be clipped.
*/
// Can not fail.
	{
	asm("ldr r12, [r0] ");				// r12=iCount
	asm("cmp r12, #0 ");
	__JUMP(eq,lr);
	asm("stmfd sp!, {r4-r10,lr} ");
	asm("ldmia r1, {r2-r5} ");			// get coordinates of aRect into r2-r5
	asm("ldr r1, [r0, #8] ");			// r1 points to first rectangle
	asm("cmn r1, r1 ");
	asm("ldrcc r1, [r0, #16] ");		// if RRegion
	asm("addcs r1, r0, #20 ");			// RRegionBuf
	asm("submi r1, r1, #8 ");			// TRegionFix

	asm("cliprect1: ");
	asm("ldmia r1!, {r6-r9} ");			// next rectangle coordinates into r6-r9
	asm("cmp r6, r2 ");					// clip the rectangle to aRect
	asm("movlt r6, r2 ");	
	asm("strlt r2, [r1, #-16] ");
	asm("cmp r7, r3 ");
	asm("movlt r7, r3 ");
	asm("strlt r3, [r1, #-12] ");
	asm("cmp r8, r4 ");
	asm("movgt r8, r4 ");
	asm("strgt r4, [r1, #-8] ");
	asm("cmp r9, r5 ");
	asm("movgt r9, r5 ");
	asm("strgt r5, [r1, #-4] ");
	asm("cmp r6, r8 ");					// check if clipped rect is empty
	asm("cmplt r7, r9 ");				// empty if r6>=r8 or r7>=r9
	asm("bge cliprect_delete ");		// if empty, branch to other loop to delete rect 
	asm("subs r12, r12, #1 ");			// decrement loop counter
	asm("bne cliprect1 ");				// loop if any more rectangles to do
	__POPRET("r4-r10,");

	asm("cliprect_delete: ");			// (enter loop here)
	asm("ldr lr, [r0] ");				// lr=iCount, updateed if we delete rects
	asm("sub r10, r1, #16 ");			// r1 -> next rect, r10 -> previous deleted rect
	asm("subs r12, r12, #1 ");			// decrement loop counter
	asm("beq cliprect_move_end ");	
	asm("cliprect_move: ");
	asm("ldmia r1!, {r6-r9} ");			// next rectangle coordinates into r6-r9
	asm("cmp r6, r2 ");					// clip the rectangle to aRect
	asm("movlt r6, r2 ");
	asm("cmp r7, r3 ");
	asm("movlt r7, r3 ");
	asm("cmp r8, r4 ");
	asm("movgt r8, r4 ");
	asm("cmp r9, r5 ");
	asm("movgt r9, r5 ");
	asm("cmp r6, r8 ");					// check if clipped rect is empty
	asm("cmplt r7, r9 ");				// empty if r6>=r8 or r7>=r9
	asm("stmltia r10!, {r6-r9} ");		// if non-empty then store the rect
	asm("subge lr, lr, #1 ");			// else decrement rect count	
	asm("subs r12, r12, #1 ");			// decrement loop counter
	asm("bne cliprect_move ");			// loop if any more rectangles to do
	asm("cliprect_move_end: ");	
	asm("sub lr, lr, #1 ");				// decrement count for first deleted rect
	asm("str lr, [r0] ");				// store updated iCount
	__POPRET("r4-r10,");	
	}



	
__NAKED__ EXPORT_C void TRegion::SubRect(const TRect& /*aRect*/,TRegion* /*aSubtractedRegion*/)
/**
Removes a rectangle from this region.

If there is no intersection between the rectangle and this region, then this 
region is unaffected. 

@param aRect             The rectangular area to be removed from this region. 
@param aSubtractedRegion A pointer to a region. If this is supplied, the
                         removed rectangle is added to it. By default this
                         pointer is NULL.
*/
	{
	asm("ldr r12, [r0] ");			// r12=iCount=limit
	asm("cmp r12, #0 ");
	__JUMP(eq,lr);
	asm("stmfd sp!, {r3-r11,lr} ");
	asm("ldmia r1, {r4-r7} ");		// r4-r7 = coordinates of aRect
	asm("cmp r4, r6 ");				// check if aRect is empty i.e. (r4>=r6 || r5>=r7)
	asm("cmplt r5, r7 ");
	asm("bge subrect_end ");		// if aRect is empty nothing to do

	asm("mov r3, #0 ");				// r3=index
	asm("subrect1: ");
	asm("ldr lr, [r0, #8] ");		// lr points to first rectangle
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r0, #16] ");	// if RRegion
	asm("addcs lr, r0, #20 ");		// RRegionBuf
	asm("submi lr, lr, #8 ");		// TRegionFix
	asm("add lr, lr, r3, lsl #4 ");	// lr=iRectangleList+index
//	asm("ldmia r1, {r4-r7} ");		// r4-r7 = coordinates of aRect
	asm("ldmia lr, {r8-r11} ");		// r8-r11 = coordinates of next rectangle in region
	asm("cmp r10, r4 ");			// compare next.iBr.iX with aRect.iTl.iX
	asm("cmpgt r11, r5 ");			// if >, compare next.iBr.iY with aRect.iTl.iY
	asm("cmpgt r6, r8 ");			// if >, compare aRect.iBr.iX with next.iTl.iX
	asm("cmpgt r7, r9 ");			// if >, compare aRect.iBr.iY with next.iTl.iY
	asm("addle r3, r3, #1 ");		// if empty intersection, increment index
	asm("ble subrect2 ");			// if <=, next and aRect have empty intersection, so skip
	asm("add r4, lr, #16 ");		// r4 = source pointer for copy, lr = dest
	asm("ldr r5, [r0] ");			// r5 = iCount
	asm("sub r5, r5, #1 ");			// decrement iCount
	asm("str r5, [r0] ");
	asm("sub r12, r12, #1 ");		// decrement limit
	asm("subs r5, r5, r3 ");		// loop count for copy = iCount-index
	asm("beq subrect4 ");			// if loop count zero, skip the copy
	asm("stmfd sp!, {r8,r9} ");		// preserve r8,r9
	asm("subrect3: ");
	asm("ldmia r4!, {r6-r9} ");		// remove the current rectangle
	asm("stmia lr!, {r6-r9} ");
	asm("subs r5, r5, #1 ");
	asm("bne subrect3 ");
	asm("ldmfd sp!, {r8-r9} ");		// restore r8,r9
	asm("subrect4: ");
	asm("ldmia r1, {r4-r7} ");		// restore coordinates of aRect into r4-r7
	asm("cmp r7, r11 ");			// compare aRect.iBr.iY with rect.iBr.iY
	asm("movgt r7, r11 ");			// r7=inter.iBr.iY
	asm("bllt subrectapp1 ");		// if <, append 1st subrectangle
	asm("cmp r5, r9 ");				// compare aRect.iTl.iY with rect.iTl.iY
	asm("movlt r5, r9 ");			// r5=inter.iTl.iY
	asm("blgt subrectapp2 ");		// if >, append 2nd subrectangle
	asm("cmp r6, r10 ");			// compare aRect.iBr.iX with rect.iBr.iX
	asm("movgt r6, r10 ");			// r6=inter.iBr.iX
	asm("bllt subrectapp3 ");		// if <, append 3rd subrectangle
	asm("cmp r4, r8 ");				// compare aRect.iTl.iX with rect.iTl.iX
	asm("movlt r4, r8 ");			// r4=inter.iTl.iX
	asm("blgt subrectapp4 ");		// if >, append 4th subrectangle
	asm("ldr lr, [r0, #4] ");		// lr=iError
	asm("cmp lr, #0 ");				// check for an error
	asm("bne subrect_end ");
	asm("cmp r2, #0 ");				// check if aSubtractedRegion!=NULL
	asm("blne subrectadd ");		// if non-null, add inter to aSubtractedRegion
	asm("subrect2: ");
	asm("cmp r3, r12 ");			// compare index to limit
	asm("ldmltia r1, {r4-r7} ");	// if index<limit, r4-r7 = coordinates of aRect
	asm("blt subrect1 ");			// if index<limit, loop again

	asm("subrect_end: ");
	__POPRET("r3-r11,");

	// AppendRect(TRect(rect.iTl.iX,inter.iBr.iY,rect.iBr.iX,rect.iBr.iY))
	asm("subrectapp1: ");
	asm("stmfd sp!, {r0-r3,r12,lr} ");			// preserve registers across function call
	asm("bl  " CSM_Z16AllocAnotherRectP7TRegion);
	asm("ldmfd sp!, {r0-r3} ");
	asm("beq subrectapp1_end ");		// exit if error

	asm("ldr r12, [r0] ");				// r12=iCount
	asm("ldr lr, [r0, #8] ");		// lr points to first rectangle
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r0, #16] ");	// if RRegion
	asm("addcs lr, r0, #20 ");		// RRegionBuf
	asm("submi lr, lr, #8 ");		// TRegionFix
	asm("add lr, lr, r12, lsl #4 ");	// lr=&(iRectangleList[iCount])
	asm("add r12, r12, #1 ");			// increment iCount
	asm("str r12, [r0] ");				//
	asm("stmia lr!, {r8} ");			// append rectangle - rect.iTl.iX
	asm("stmia lr!, {r7,r10,r11} ");	// inter.iBr.iY, rect.iBr.iX, rect.iBr.iY
	asm("subrectapp1_end: ");
	__POPRET("r12,");

	// AppendRect(TRect(rect.iTl.iX,rect.iTl.iY,rect.iBr.iX,inter.iTl.iY))
	asm("subrectapp2: ");
	asm("stmfd sp!, {r0-r3,r12,lr} ");			// preserve registers across function call
	asm("bl  " CSM_Z16AllocAnotherRectP7TRegion);
	asm("ldmfd sp!, {r0-r3} ");
	asm("beq subrectapp1_end ");		// exit if error

	asm("ldr r12, [r0] ");				// r12=iCount
	asm("ldr lr, [r0, #8] ");		// lr points to first rectangle
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r0, #16] ");	// if RRegion
	asm("addcs lr, r0, #20 ");		// RRegionBuf
	asm("submi lr, lr, #8 ");		// TRegionFix
	asm("add lr, lr, r12, lsl #4 ");	// lr=&(iRectangleList[iCount])
	asm("add r12, r12, #1 ");			// increment iCount
	asm("str r12, [r0] ");				//
	asm("stmia lr!, {r8,r9,r10} ");		// append rectangle - rect.iTl.iX,rect.iTl.iY,rect.iBr.iX
	asm("stmia lr!, {r5} ");			// inter.iTl.iY
	__POPRET("r12,");

	// AppendRect(TRect(inter.iBr.iX,inter.iTl.iY,rect.iBr.iX,inter.iBr.iY))
	asm("subrectapp3: ");
	asm("stmfd sp!, {r0-r3,r12,lr} ");			// preserve registers across function call
	asm("bl  " CSM_Z16AllocAnotherRectP7TRegion);
	asm("ldmfd sp!, {r0-r3} ");
	asm("beq subrectapp1_end ");		// exit if error
	asm("ldr r12, [r0] ");				// r12=iCount
	asm("ldr lr, [r0, #8] ");		// lr points to first rectangle
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r0, #16] ");	// if RRegion
	asm("addcs lr, r0, #20 ");		// RRegionBuf
	asm("submi lr, lr, #8 ");		// TRegionFix
	asm("add lr, lr, r12, lsl #4 ");	// lr=&(iRectangleList[iCount])
	asm("add r12, r12, #1 ");			// increment iCount
	asm("str r12, [r0] ");				//
	asm("stmia lr!, {r6} ");			// append rectangle - inter.iBr.iX
	asm("stmia lr!, {r5,r10} ");		// inter.iTl.iY, rect.iBr.iX
	asm("stmia lr!, {r7} ");			// inter.iBr.iY
	__POPRET("r12,");

	// AppendRect(TRect(rect.iTl.iX,inter.iTl.iY,inter.iTl.iX,inter.iBr.iY))
	asm("subrectapp4: ");
	asm("stmfd sp!, {r0-r3,r12,lr} ");			// preserve registers across function call
	asm("bl  " CSM_Z16AllocAnotherRectP7TRegion);
	asm("ldmfd sp!, {r0-r3} ");
	asm("beq subrectapp1_end ");		// exit if error
	asm("ldr r12, [r0] ");				// r12=iCount
	asm("ldr lr, [r0, #8] ");		// lr points to first rectangle
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r0, #16] ");	// if RRegion
	asm("addcs lr, r0, #20 ");		// RRegionBuf
	asm("submi lr, lr, #8 ");		// TRegionFix
	asm("add lr, lr, r12, lsl #4 ");	// lr=&(iRectangleList[iCount])
	asm("add r12, r12, #1 ");			// increment iCount
	asm("str r12, [r0] ");				//
	asm("stmia lr!, {r8} ");			// append rectangle - rect.iTl.iX
	asm("stmia lr!, {r5} ");			// inter.iTl.iY
	asm("stmia lr!, {r4,r7} ");			// inter.iTl.iX, inter.iBr.iY
	__POPRET("r12,");

	// aSubtractedRegion->AddRect(inter)
	asm("subrectadd: ");
	asm("stmfd sp!, {r0-r7,r12,lr} ");	// preserve registers and put inter onto stack
	asm("mov r0, r2 ");					// this = aSubtractedRegion
	asm("add r1, sp, #16 ");			// inter is 16 bytes above sp
	asm("bl  " CSM_ZN7TRegion7AddRectERK5TRect);	// call TRegion::AddRect
	__POPRET("r0-r7,r12,");
	}




__NAKED__ EXPORT_C void TRegion::Intersection(const TRegion& /*aRegion1*/,const TRegion& /*aRegion2*/)
/**
Replaces this region with the area of intersection between two specified regions.
	
Notes:
	
1. If the error flag of either of the two specified regions is set, then this 
   region is cleared and its error flag is set. This frees up allocated memory.
	
2. If this region's error flag is already set, then the function has no effect.
	
@param aRegion1 The first region. 
@param aRegion2 The second region.
*/
	{
	// r0=this, r1=&aRegion1, r2=&aRegion2
	asm("ldr r3, [r1, #4] ");			// r3=aRegion1.iError
	asm("ldr r12, [r2, #4] ");			// r12=aRegion2.iError
	asm("orrs r3, r3, r12 ");
	asm("bne  " CSM_ZN7TRegion10ForceErrorEv);	// if either set, ForceError()
	asm("str r3, [r0] ");				// iCount=0
	asm("ldr r3, [r1] ");				// r3=aRegion1.iCount
	asm("ldr r12, [r2] ");				// r12=aRegion2.iCount
	asm("cmp r3, #0 ");
	asm("cmpne r12, #0 ");
	__JUMP(eq,lr);
	asm("stmfd sp!, {r3-r11,lr} ");
	asm("ldr lr, [r1, #8] ");			// r1 points to first rectangle of aRegion1 = pRect1
	asm("cmn lr, lr ");
	asm("ldrcc r1, [r1, #16] ");		// if RRegion
	asm("addcs r1, r1, #20 ");			// RRegionBuf
	asm("submi r1, r1, #8 ");			// TRegionFix
	asm("intersection1: ");
	asm("ldr lr, [r2, #8] ");			// lr points to first rectangle of aRegion2
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r2, #16] ");		// if RRegion
	asm("addcs lr, r2, #20 ");			// RRegionBuf
	asm("submi lr, lr, #8 ");			// TRegionFix
	asm("ldr r12, [r2] ");				// r12=aRegion2.iCount
	asm("intersection2: ");
	asm("ldmia r1, {r4-r7} ");			// r4-r7 = *pRect1
	asm("ldmia lr!, {r8-r11} ");		// r8-r11 = *pRect2++
	asm("cmp r6, r8 ");					// compare pRect1->iBr.iX with pRect2->iTl.iX
	asm("cmpgt r7, r9 ");				// if >, compare pRect1->iBr.iY with pRect2->iTl.iY
	asm("cmpgt r10, r4 ");				// if >, compare pRect2->iBr.iX with pRect1->iTl.iX
	asm("cmpgt r11, r5 ");				// if >, compare pRect2->iBr.iY with pRect1->iTl.iY
	asm("ble intersection3 ");			// if <=, rectangles have empty intersection, so iterate
	asm("cmp r4, r8 ");					// compute intersection and place in r8-r11
	asm("movgt r8, r4 ");
	asm("cmp r5, r9 ");
	asm("movgt r9, r5 ");
	asm("cmp r6, r10 ");
	asm("movlt r10, r6 ");
	asm("cmp r7, r11 ");
	asm("movlt r11, r7 ");
	asm("stmfd sp!, {r0-r3,r12,lr} ");	// preserve registers across function call
	asm("bl  " CSM_Z16AllocAnotherRectP7TRegion);
	asm("ldmfd sp!, {r0-r3} ");
	asm("ldmeqfd sp!, {r12,lr} ");		// exit if error
	asm("beq intersection_end ");

	asm("ldr r12, [r0] ");				// r12=iCount
	asm("ldr lr, [r0, #8] ");			// lr points to first rectangle
	asm("cmn lr, lr ");
	asm("ldrcc lr, [r0, #16] ");		// if RRegion
	asm("addcs lr, r0, #20 ");			// RRegionBuf
	asm("submi lr, lr, #8 ");			// TRegionFix
	asm("add lr, lr, r12, lsl #4 ");	// lr=&(iRectangleList[iCount])
	asm("add r12, r12, #1 ");			// increment iCount
	asm("str r12, [r0] ");				//
	asm("stmia lr!, {r8-r11} ");		// append intersection of rectangles
	asm("ldmfd sp!, {r12,lr} ");		// restore registers
	asm("intersection3: ");
	asm("subs r12, r12, #1 ");
	asm("bne intersection2 ");			// loop for all values of pRect2
	asm("add r1, r1, #16 ");			// increment pRect1
	asm("subs r3, r3, #1 ");
	asm("bne intersection1 ");			// loop for all values of pRect1

	asm("intersection_end: ");
	__POPRET("r3-r11,");
	}
	
#endif




#ifdef __COBJECT_MACHINE_CODED__
__NAKED__ EXPORT_C CObject *CObjectIx::At(TInt /*aHandle*/,TInt /*aUniqueID*/)
/**
Gets a pointer to the reference counting object with the specified handle
number and matching unique ID.

@param aHandle   The handle number of the reference counting object.
@param aUniqueID The unique ID.

@return A pointer to the reference counting object. If there is no matching 
        object, then this is NULL.
*/
	{
	// r0=this, r1=aHandle, r2=aUniqueID
	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(CObjectIx,iHighWaterMark));	// r3=iHighWaterMark
	asm("ldr r0, [r0, #%a0]" : : "i" _FOFF(CObjectIx,iObjects));	// r0=iObjects
	asm("mov r12, r1, lsl #17 ");		// r12=r1<<17 = index(aHandle)<<17
	asm("cmp r3, r12, lsr #17 ");		// compare iHighWaterMark with index(aHandle)
	asm("movle r0, #0 ");				// if hwm<=index, return NULL
	__JUMP(le,lr);
	asm("add r0, r0, r12, lsr #14 ");	// r0=iObjects+index(Handle)=pS
	asm("ldr r3, [r0] ");				// r3=pS->uniqueID:pS->instance
	asm("mov r1, r1, lsl #2 ");			// r1=instance(Handle)<<18
	asm("mov r1, r1, lsr #18 ");		// r1=instance(Handle)
	asm("orr r1, r1, r2, lsl #16 ");	// r1=aUniqueID:instance(Handle)
	asm("cmp r1, r3 ");					// check uniqueID and instance
	asm("movne r0, #0 ");				// if wrong, return 0
	asm("ldreq r0, [r0, #4] ");			// else return pointer to CObject
	__JUMP(,lr);
	}




__NAKED__ EXPORT_C CObject *CObjectIx::At(TInt aHandle)
/**
Gets a pointer to the reference counting object with the specified
handle number.

@param aHandle The handle number of the reference counting object.

@return A pointer to the reference counting object. If there is no matching 
        object, then this is NULL.
*/
	{
	// r0=this, r1=aHandle
	asm("ldr r3, [r0, #%a0]" : : "i" _FOFF(CObjectIx,iHighWaterMark));	// r3=iHighWaterMark
	asm("ldr r0, [r0, #%a0]" : : "i" _FOFF(CObjectIx,iObjects));	// r0=iObjects
	asm("mov r12, r1, lsl #17 ");		// r12=r1<<17 = index(aHandle)<<17
	asm("cmp r3, r12, lsr #17 ");		// compare iHighWaterMark with index(aHandle)
	asm("movle r0, #0 ");				// if hwm<=index, return NULL
	__JUMP(le,lr);
	asm("add r0, r0, r12, lsr #14 ");	// r0=iObjects+index(Handle)=pS
	asm("ldr r3, [r0] ");				// r3=pS->uniqueID:pS->instance
	asm("ldr r2, __instanceMask ");
	asm("and r1, r1, r2 ");				// r1=instance(Handle)<<16
	asm("cmp r1, r3, lsl #16 ");		// check instance
	asm("movne r0, #0 ");				// if wrong, return 0
	asm("ldreq r0, [r0, #4] ");			// else return pointer to CObject
	__JUMP(,lr);
	asm("__instanceMask: ");
	asm(".word 0x3FFF0000 ");
	}




GLREF_C void PanicCObjectIxIndexOutOfRange(void);




__NAKED__ EXPORT_C CObject* CObjectIx::operator[](TInt /*anIndex*/)
/**
Gets a pointer to a reference counting object located at the specified offset 
within the object index.

@param anIndex The offset of the reference counting object within the object 
               index. Offset is relative to zero. 
               
@return A pointer to the reference counting object.

@panic E32USER-CBase 21 if the value of anIndex is negative or is greater than
                        or equal to the total number of objects held by
                        the index.
*/
	{
	// r0=this, r1=anIndex
	asm("cmp r1, #0 ");								// check anIndex>=0
	asm("ldrge r3, [r0, #%a0]" : : "i" _FOFF(CObjectIx,iHighWaterMark));	// if so, r3=iHighWaterMark
	asm("cmpge r3, r1 ");							// and compare iHighWaterMark to anIndex
	asm("ldrgt r0, [r0, #%a0]" : : "i" _FOFF(CObjectIx,iObjects));	// if OK, r0=iObjects
	asm("addgt r0, r0, r1, lsl #3 ");				// r0=iObjects+anIndex
	asm("ldrgt r0, [r0, #4] ");						// r0=pointer to CObject
#ifdef __CPU_ARMV6
	asm("ble 1f ");
	__JUMP(,lr);
#else
	__JUMP(gt,lr);
#endif
	asm("1: ");
	asm("b  " CSM_Z29PanicCObjectIxIndexOutOfRangev);	// if anIndex<0 or iCount<=anIndex, panic
	}




GLREF_C void PanicCObjectConIndexOutOfRange(void);
GLREF_C void PanicCObjectConFindBadHandle(void);
GLREF_C void PanicCObjectConFindIndexOutOfRange(void);




__NAKED__ EXPORT_C CObject *CObjectCon::operator[](TInt /*anIndex*/)
/**
Gets a pointer to the reference counting object located at the specified offset 
within the object container.

@param anIndex The offset of the reference counting object within the object 
               container. Offset is relative to zero.

@return A pointer to the owning reference counting object.

@panic E32USER-CBase 21 if anIndex is negative or is greater than or equal to
                        the total number of objects held by the container.
*/
	{
	// r0=this, r1=anIndex
	asm("cmp r1, #0 ");
	asm("ldrge r2, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iCount));
	asm("cmpge r2, r1 ");
	asm("ldrgt r0, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iObjects));
	asm("ldrgt r0, [r0, r1, lsl #2] ");
#ifdef __CPU_ARMV6
	asm("ble 1f ");
	__JUMP(,lr);
#else
	__JUMP(gt,lr);
#endif
	asm("1: ");
	asm("b  " CSM_Z30PanicCObjectConIndexOutOfRangev);
	}




__NAKED__ EXPORT_C CObject *CObjectCon::At(TInt /*aFindHandle*/) const
/**
Gets a pointer to the reference counting object with the specified find-handle 
number.

A find-handle number is an integer which uniquely identifies a reference
counting object with respect to its object container.

@param aFindHandle The find-handle number of the reference counting object. 
                   The unique Id part of this number must be the same as the
                   unique Id of this container.
                   The index part of the find-handle number must be
                   a valid index. 

@return A pointer to the reference counting object.

@panic E32User-CBase 38 if the unique Id part of aFindHandle is not the same as
                        the unique Id of this container.
@panic E32User-CBase 39 if the index part of aFindHandle is negative or greater
                        than or equal to the total number of reference counting
                        objects held by this object container.
*/
	{
	// r0=this, r1=aFindHandle
	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iUniqueID));
	asm("cmp r2, r1, lsr #16 ");
	asm("ldreq r2, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iCount));
	asm("bne  " CSM_Z28PanicCObjectConFindBadHandlev);
	asm("mov r1, r1, lsl #17 ");
	asm("cmp r2, r1, lsr #17 ");
	asm("ldrgt r0, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iObjects));
	asm("ble  " CSM_Z34PanicCObjectConFindIndexOutOfRangev);
	asm("ldr r0, [r0, r1, lsr #15] ");
	__JUMP(,lr);
	}




__NAKED__ EXPORT_C CObject *CObjectCon::AtL(TInt /*aFindHandle*/) const
/**
Gets a pointer to the reference counting object with the specified find-handle 
number, and leaves on error.

A find-handle number is an integer which uniquely identifies a reference
counting object with respect to its object container.

@param aFindHandle The find-handle number of the reference counting object. 
                   The unique Id part of this number must be the same as
                   the unique Id of this container.
                   The index part of the find-handle number must be
                   a valid index. 

@return A pointer to the reference counting object.

@leave KErrBadHandle if the unique Id part of aFindHandle is not the same as
                     the unique Id of this container.
@leave KErrArgument if the index part of aFindHandle is negative or greater
                    than or equal to the total number of reference counting
                    objects held by this object container.
*/
	{
	// r0=this, r1=aFindHandle
	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iUniqueID));
	asm("cmp r2, r1, lsr #16 ");
	asm("ldreq r2, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iCount));
	asm("bne 1f ");
	asm("mov r1, r1, lsl #17 ");
	asm("cmp r2, r1, lsr #17 ");
	asm("ldrgt r0, [r0, #%a0]" : : "i" _FOFF(CObjectCon,iObjects));
	asm("ble 2f ");
	asm("ldr r0, [r0, r1, lsr #15] ");
	__JUMP(,lr);
	// User::Leave tail called, so no annotations required since
	// current frame is reused by User::Leave
	asm("1: ");
	asm("mvn r0, #7 "); // KErrBadHandle
	asm("b  " CSM_ZN4User5LeaveEi);
	asm("2: ");
	asm("mvn r0, #5 "); // KErrArgument
	asm("b  " CSM_ZN4User5LeaveEi);
	}
#endif

#ifdef __CACTIVESCHEDULER_MACHINE_CODED__
extern "C" void PanicStrayEvent();

/**
@internalComponent

The inner active scheduler loop. This repeatedly waits for a signal and then
dispatches the highest priority ready active object. The loop terminates either
if one of the RunL()s stops the current active scheduler level or leaves.

Stop when aLoop becomes 'Inactive'
*/
__NAKED__ void CActiveScheduler::DoRunL(TLoopOwner* const volatile& aLoop, CActive* volatile & aCurrentObj, TCleanupBundle* aCleanupBundlePtr)
	{
	asm("stmfd sp!, {r4-r8,lr} ");
	__EH_FRAME_PUSH2(r4-r8,lr)
	
#ifdef _DEBUG
	// need to copy aCleanupBundlePtr to somewhere else before it's clobbered by the next line.
	asm("mov r8, r3 ");														// r8 = &aCleanupBundlePtr
#endif
	
	asm("ldr r3, [r0, #%a0]" : : "i" (_CBASE_VPTR_OFFSET_));				// r3 = vptr
	asm("add r4, r0, #%a0" : : "i" _FOFF(CActiveScheduler,iActiveQ));		// r4 = &iActiveQ
	asm("mov r5, r1 ");														// r5 = &aLoop
	asm("mov r7, r2 ");														// r7 = &aCurrentObj
	asm("ldr r6, [r3, #%a0]" : : "i" (_CACTIVESCHEDULER_WAIT_OFFSET_));		// r6 = &WaitForAnyRequest()

	asm("active_scheduler_loop: ");
	asm("ldr r1, [r5] ");													// r1 = aLoop
	asm("adr lr, 1f ");														// return address
	asm("sub r0, r4, #%a0 " : : "i" _FOFF(CActiveScheduler,iActiveQ));		// this
	asm("cmp r1, #0 ");
	__JUMP(ne, r6);															// call WaitForAnyRequest() if still active
	__POPRET("r4-r8,");														// else return

	// get here when WaitForAnyRequest() returns
	asm("1: ");
	asm("ldr r14, [r4, #0] ");												// r14->first active object

	asm("2: ");
	asm("cmp r14, r4 ");													// end of queue?
	asm("sub r0, r14, #%a0" : : "i" _FOFF(CActive,iLink));					// r0->CActive
	asm("ldmneda r14, {r2, r12, r14} ");									// r2=iStatus, r12=iStatus.iFlags (old iActive), r14 = next object
	asm("beq PanicStrayEvent ");											// if end of queue, panic
#ifdef _DEBUG
	asm("ands r3, r12, #%a0" : : "i" ((TInt)(TRequestStatus::EActive|TRequestStatus::ERequestPending)));	// only active bit and request-pending bit
	asm("cmpne r3, #%a0" : : "i" ((TInt)(TRequestStatus::EActive|TRequestStatus::ERequestPending)));		// active bit == request pending bit
	asm("bne PanicStrayEvent ");											// if active bit != request pending bit, panic
#endif
	asm("cmp r2, #%a0" : : "i" ((TInt)KRequestPending));					// test if iStatus!=KRequestPending
	asm("andnes r3, r12, #%a0" : : "i" ((TInt)TRequestStatus::EActive));	// if so, test iActive
	asm("beq 2b ");															// if not active or still pending, do next CActive

	// have an active object to run
#ifdef __SMP__
	__DATA_MEMORY_BARRIER_Z__(r3);											// acquire semantics
#endif
	asm("ldr r3, [r0, #%a0]" : : "i" (_CBASE_VPTR_OFFSET_));				// r3=CActive->vptr
	asm("bic r12, r12, #%a0" : : "i" ((TInt)(TRequestStatus::EActive|TRequestStatus::ERequestPending)));
	asm("ldr r3, [r3, #%a0]" : : "i" (_CACTIVE_RUNL_OFFSET_));				// r3 = &CActive::RunL()
	asm("str r12, [r0, #%a0]" : : "i" (_FOFF(CActive,iStatus)+_FOFF(TRequestStatus,iFlags)));	// iActive=EFalse
	asm("str r0, [r7] ");													// save active object in aCurrentObj in case RunL leaves
#ifdef _DEBUG
	__JUMPL(3);															// call RunL() (and continue)
#else
	asm("adr lr, active_scheduler_loop ");								// set lr (return address) to label, active_scheduler_loop
	__JUMP(,r3);														// call RunL() (and loop)
#endif
	
	
#ifdef _DEBUG
	//check whether there's a cleanup stack installed:

	asm("cmp r8, #0");															// check CleanupBundle* == NULL
	asm("beq active_scheduler_loop ");											// If r8 == NULL, branch to label, active_scheduler_loop
	asm("ldr r0, [r8, #%a0]" : : "i" _FOFF(TCleanupBundle,iCleanupPtr)); 		// r0 = CCleanup* (load the CCleanup*)

	//there is a cleanupstack installed:
	asm("add r1, r8, #%a0" : : "i" _FOFF(TCleanupBundle,iDummyInt)); 			// r1 = iDummyInt* (load the TInt*)
	asm("adr lr, active_scheduler_loop ");										// set lr (return address) to label, active_scheduler_loop
	asm("b  " CSM_ZN8CCleanup5CheckEPv); 										// call CCleanup::Check(iDummyInt*)
#endif
	
	}
#endif


#ifdef __CSERVER_MACHINE_CODED__
__NAKED__ EXPORT_C void CServer2::RunL()
	{
	asm("ldr r2, [r0, #%a0]" : : "i" _FOFF(CServer2,iMessage.iFunction)); // r2=Message().Function()
	asm("stmfd sp!, {r4, lr}");			// save regs
	__EH_FRAME_PUSH2(r4,lr)
	asm("cmp r2, #0");					// check for Connect/Disconnect message
	asm("bmi server2_con_dis");

	// Service the message
	asm("mov r4, r0 ");						// r4=this
	asm("ldr r0, [r4, #%a0]" : : "i" _FOFF(CServer2,iMessage.iSessionPtr)); // r0=session
	asm("add r1, r4, #%a0" : : "i" (_FOFF(CServer2,iMessage)));	// r1=&iServer.Message()
	asm("cmp r0, #0");  // Check for NULL session
	asm("ldrne r12, [r0, #%a0]" : : "i" (_CBASE_VPTR_OFFSET_));			// r12=CSession2::vptr
#ifdef __SUPPORT_THUMB_INTERWORKING
	asm("ldrne r3, [r12, #%a0]" : : "i" (_CSESSION2_SERVICEL_OFFSET_));	// call CSession2::ServiceL(iMessage)
	asm("adr lr, server2_run_postamble ");
	asm("bxne r3 ");
#else
	asm("adr lr, server2_run_postamble ");
	asm("ldrne pc, [r12, #%a0]" : : "i" (_CSESSION2_SERVICEL_OFFSET_));	// call CSession2::ServiceL(iMessage)
#endif
	asm("mov r0, r1");
	asm("b  " CSM_ZN8CServer212NotConnectedERK9RMessage2); // NULL session ptr means not connected

	// Do this after processing any message
	asm("server2_run_postamble: ");
	asm("ldr r2, [r4, #%a0]" : : "i" (_FOFF(CServer2,iStatus)+_FOFF(TRequestStatus,iFlags)));	// r2=iStatus.iFlags (old iActive)
	asm("mov r0, #0x80000001 ");								// r0=KRequestPending
	asm("ands r1, r2, #%a0" : : "i" ((TInt)TRequestStatus::EActive));
	asm("bne server2_run_end ");							// if already active, finished
	asm("orr r2, r2, #%a0" : : "i" ((TInt)(TRequestStatus::EActive|TRequestStatus::ERequestPending)));
	asm("add r1, r4, #%a0" : : "i" _FOFF(CActive,iStatus));		// r1->iStatus
	asm("stmia r1, {r0,r2} "); // set iStatus=KRequestPending, set active bit, set request pending bit
	asm("add r2, r4, #%a0" : : "i" _FOFF(CServer2,iMessage));	// r2->iServer.Message()
	asm("ldr r0, [r4, #%a0]" : : "i" _FOFF(CServer2,iServer));	// r0=iServer.iHandle
	asm("bl  " CSM_ZN4Exec13ServerReceiveEiR14TRequestStatusPv);// call Exec::ServerReceive
	asm("server2_run_end: ");
	__POPRET("r4,");

	// Deal with Connect and Disconnect messages
	asm("server2_con_dis:");	
	asm("mov r4, r0 ");					// r4=this
	asm("add r1, r0, #%a0" : : "i" _FOFF(CServer2,iMessage)); // r1=&iServer.Message()
	asm("adr lr, server2_run_postamble "); // return address for after any processing
	asm("cmp r2, #%a0" : : "i" (RMessage2::EConnect));
	asm("beq  " CSM_ZN8CServer27ConnectERK9RMessage2); // Do Connect()
	asm("cmp r2, #%a0" : : "i" (RMessage2::EDisConnect));
	asm("beq  " CSM_ZN8CServer210DisconnectERK9RMessage2); // Do Disconnect()
	asm("mov r0, r1");
	asm("b  " CSM_ZN8CServer210BadMessageERK9RMessage2); // Bad message
	}
#endif

EXPORT_C __NAKED__ void RFastLock::Wait()
	{
	asm("1: ");
	asm("add	r0, r0, #4 ");					// point to iCount

#ifdef __CPU_ARM_HAS_LDREX_STREX
	asm("2:		");
	LDREX(		2, 0);							// read
	asm("subs	r1, r2, #1 ");					// decrement
	STREX(		3, 1, 0);						// write
	asm("teq	r3, #0 ");						// success?
	asm("bne	2b ");							// no!
	asm("sub	r0, r0, #4 ");					// r0 = this
	asm("bcs "	CSM_ZN10RSemaphore4WaitEv);		// if no borrow from decrement wait on semaphore
#ifdef __SMP__
	__DATA_MEMORY_BARRIER__(r3);				// no need to wait, but still need acquire barrier
#endif
	__JUMP(,	lr );
#else
	asm("mov	r1, #1 ");						// 'looking' value
	asm("swp	r1, r1, [r0] ");				// write looking value, read original
	asm("subs	r1, r1, #1 ");					// decrement count
	asm("strlt	r1, [r0] ");					// if it becomes negative, no-one was looking
	__JUMP(cc,	lr);							// if borrow, was originally zero so we are finished
	asm("sub	r0, r0, #4 ");					// r0=this
	asm("blt "	CSM_ZN10RSemaphore4WaitEv);		// lock held so wait on semaphore
	asm("stmfd	sp!, {r0,lr} ");				// otherwise save registers
	asm("mov	r0, #1000 ");					// someone was looking, so wait 1ms and try again
	asm("bl "	CSM_ZN4User12AfterHighResE27TTimeIntervalMicroSeconds32);
	asm("ldmfd	sp!, {r0,lr} ");
	asm("b		1b ");
#endif
	}

EXPORT_C __NAKED__ TInt RFastLock::Poll()
	{
	asm("1: ");
	asm("add	r0, r0, #4 ");					// point to iCount

#ifdef __CPU_ARM_HAS_LDREX_STREX
	asm("2:		");
	LDREX(		2, 0);							// read
	asm("subs	r1, r2, #1 ");					// decrement
	asm("bcs	3f ");							// if no borrow, lock cannot be obtained so bail out
	STREX(		3, 1, 0);						// write
	asm("teq	r3, #0 ");						// success?
	asm("bne	2b ");							// no!
	asm("mov	r0, #0 ");						// lock acquired so return KErrNone
#ifdef __SMP__
	__DATA_MEMORY_BARRIER__(r3);				// need acquire barrier
#endif
	__JUMP(,	lr);

	asm("3:		");
	asm("mov	r0, #%a0" : : "i" ((TInt)KErrTimedOut));	// else can't get it immediately so return KErrTimedOut
	__JUMP(,	lr);
#else	// no LDREX/STREX - ARM arch 5 CPU
	asm("mov	r1, #1 ");						// 'looking' value
	asm("swp	r1, r1, [r0] ");				// write looking value, read original
	asm("subs	r2, r1, #1 ");					// decrement count
	asm("strcc	r2, [r0] ");					// if borrow, was originally zero so write back -1 and return KErrNone
	asm("movcc	r0, #0 ");						// got lock - return KErrNone
 	__JUMP(cc,	lr);

	asm("strlt	r1, [r0] ");					// else if result<0 (i.e. wasn't looking value) write back original
	asm("mov	r0, #%a0" : : "i" ((TInt)KErrTimedOut));	// else can't get it immediately so return KErrTimedOut
 	__JUMP(,	lr);
#endif
	}

EXPORT_C __NAKED__ void RFastLock::Signal()
	{
	asm("1: ");
	asm("add	r0, r0, #4 ");					// point to iCount

#ifdef __CPU_ARM_HAS_LDREX_STREX
#ifdef __SMP__
	__DATA_MEMORY_BARRIER_Z__(r3);				// need release barrier
#endif
	asm("2:		");
	LDREX(		2, 0);							// read
	asm("adds	r1, r2, #1 ");					// increment
	STREX(		3, 1, 0);						// write
	asm("teq	r3, #0 ");						// success?
	asm("bne	2b ");							// no!
	asm("sub	r0, r0, #4 ");					// r0 = this
	asm("bcc "	CSM_ZN10RSemaphore6SignalEv);	// if no carry from increment, signal semaphore
	__JUMP(,	lr );
#else
	asm("mov	r1, #1 ");						// 'looking' value
	asm("swp	r1, r1, [r0] ");				// write looking value, read original
	asm("adds	r1, r1, #1 ");					// increment count
	asm("strle	r1, [r0] ");					// if still <=0, no-one was looking
	__JUMP(eq,	lr);							// if it's now zero, no-one is waiting so we are finished
	asm("sub	r0, r0, #4 ");					// r0=this
	asm("blt "	CSM_ZN10RSemaphore6SignalEv);	// someone is waiting so signal semaphore
	asm("stmfd	sp!, {r0,lr} ");				// otherwise save registers
	asm("mov	r0, #1000 ");					// someone was looking, so wait 1ms and try again
	asm("bl "	CSM_ZN4User12AfterHighResE27TTimeIntervalMicroSeconds32);
	asm("ldmfd	sp!, {r0,lr} ");
	asm("b		1b ");
#endif
	}


/**
Acquire the lock, if necessary waiting up to a specified maximum amount of time
for it to become free.

This function checks if the lock is currently held. If not the lock is marked
as held by the current thread and the call returns immediately. If the lock is
held by another thread the current thread will suspend until the lock becomes
free or until the specified timeout period has elapsed.

@param aTimeout The timeout value in microseconds

@return KErrNone if the lock was acquired successfully.
        KErrTimedOut if the timeout has expired.
        KErrGeneral if the lock is being reset, i.e the lock
        is about to  be deleted.
        KErrArgument if aTimeout is negative;
        otherwise one of the other system wide error codes.
*/
EXPORT_C __NAKED__ TInt RFastLock::Wait(TInt /*aTimeout*/)
	{
	asm("stmfd	sp!, {r4-r6,lr} ");
	asm("add	r4, r0, #4 ");					// r4->iCount
	asm("subs	r5, r1, #0 ");					// r5=aTimeout
	asm("mov	r6, #1000 ");
	asm("movle	r0, #%a0" : : "i" ((TInt)KErrArgument));	
	__CPOPRET(le, "r4-r6,");					// if aTimeout<=0 return KErrArgument
	asm("1:		");

#ifdef __CPU_ARM_HAS_LDREX_STREX
	asm("2:		");
	LDREX(		2, 4);							// read
	asm("subs	r12, r2, #1 ");					// decrement
	STREX(		3, 12, 4);						// write
	asm("teq	r3, #0 ");						// success?
	asm("bne	2b ");							// no!
	asm("bcs	8f ");							// if no borrow from decrement, need to wait
#ifdef __SMP__
	__DATA_MEMORY_BARRIER__(r3);				// no need to wait, but still need acquire barrier
#endif
#else	// no LDREX/STREX - ARM arch 5 CPU
	asm("mov	r2, #1 ");						// 'looking' value
	asm("swp	r2, r2, [r4] ");				// write looking value, read original
	asm("subs	r12, r2, #1 ");					// decrement count
	asm("strlt	r12, [r4] ");					// if it becomes negative, no-one was looking
	asm("bcs	8f ");							// if no borrow, we have to wait
#endif
	asm("mov	r0, #0 ");						// return KErrNone
	__POPRET("r4-r6,");

// We need to wait
	asm("8:		");
#ifndef __CPU_ARM_HAS_LDREX_STREX
// no LDREX/STREX - ARM arch 5 CPU
	asm("blt	3f ");							// if it wasn't 'looking' value, branch

	// it was the 'looking' value, so wait a little bit
	asm("cmp	r5, #0 ");
	asm("ble	9f ");							// waited too long already, return KErrTimedOut
	asm("sub	r5, r5, r6 ");
	asm("mov	r6, #2000 ");
	asm("mov	r0, #1000 ");					// wait 1ms
	asm("cmp	r5, r0 ");
	asm("movlt	r5, r0 ");						// remaining time at least 1ms
	asm("bl "	CSM_ZN4User12AfterHighResE27TTimeIntervalMicroSeconds32);
	asm("b		1b ");							// try again
#endif
	asm("3:		");
	asm("sub	r0, r4, #4 ");					// r0=this
	asm("mov	r1, r5 ");						// r1=aTimeout
	asm("bl "	CSM_ZN10RSemaphore4WaitEi);	// try to acquire semaphore
	asm("cmp	r0, #%a0" : : "i" ((TInt)KErrTimedOut));
	__CPOPRET(ne, "r4-r6,");					// if wait didn't time out, return
	asm("mov	r5, #1 ");						// any further timed waits will be for minimum period
	
	// Before we can return KErrTimedOut we must increment iCount (since we
	// previously decremented it in anticipation of acquiring the lock.
	// However we must not increment iCount if it would become zero, since
	// the semaphore will have been signalled (to counterbalance the Wait()
	// which timed out and thus never happened). This would result in two
	// threads being able to acquire the lock simultaneously - one by
	// decrementing iCount from 0 to -1 without looking at the semaphore,
	// and the other by decrementing iCount from -1 to -2 and then absorbing
	// the spurious semaphore signal.
	//	orig = __e32_atomic_tas_ord32(&iCount, -1, 0, 1);	// don't release lock completely
	//	if (orig < -1)
	//		return KErrTimedOut;	// count corrected - don't need to touch semaphore
	// lock is actually free at this point, try again to claim it
	//	aTimeout = 1;
#ifdef __CPU_ARM_HAS_LDREX_STREX
#ifdef __SMP__
	__DATA_MEMORY_BARRIER_Z__(r3);
#endif
	asm("4:		");
	LDREX(		2, 4);							// read
	asm("adds	r2, r2, #1 ");					// increment
	asm("bge	3b ");							// if increment would make result >=0, wait again
	STREX(		3, 2, 4);						// write
	asm("teq	r3, #0 ");						// success?
	asm("bne	4b ");							// no!
#ifdef __SMP__
	__DATA_MEMORY_BARRIER__(r3);
#endif
#else	// no LDREX/STREX - ARM arch 5 CPU
	asm("mov	r2, #1 ");						// 'looking' value
	asm("swp	r2, r2, [r4] ");				// write looking value, read original
	asm("adds	r12, r2, #1 ");					// increment count
	asm("strlt	r12, [r4] ");					// if still negative, count now fixed, so return KErrTimedOut
	asm("streq	r2, [r4] ");					// else if not 'looking' value, write back original
	asm("bge	3b ");							// if 'looking' value or -1, wait again
#endif
	asm("9:		");
	asm("mov	r0, #%a0" : : "i" ((TInt)KErrTimedOut));	// return KErrTimedOut
	__POPRET("r4-r6,");
	}


// Entry point stub to allow EKA1 binaries to be executed under EKA2
// Only called when process is first loaded

extern "C" TLinAddr GetEka1ExeEntryPoint();

__NAKED__ TInt E32Loader::V7ExeEntryStub()
	{
	// Process entry point
	// R4 = entry reason
	// SP points to information block
	asm("cmp r4, #%a0" : : "i" ((TInt)KModuleEntryReasonProcessInit) );
	asm("bne " CSM_ZN4User9InvariantEv );	// invalid entry reason
	asm("bl GetEka1ExeEntryPoint ");		// load the entry stub and return its address
	__JUMP(,r0);							// jump to the entry stub with R4, SP unchanged
	}

__NAKED__ TInt E32Loader::V7DllEntryStub(TInt)
	{

	__JUMP(,lr);
	}


// Hash an 8 bit string at aPtr, length aLen bytes.
__NAKED__ TUint32 DefaultStringHash(const TUint8* /*aPtr*/, TInt /*aLen*/)
	{
	asm("ldr r3, one_over_phi ");
	asm("subs r1, r1, #4 ");
	asm("mov r2, r0 ");
	asm("mov r0, #0 ");
	asm("blo 1f ");
	asm("ands r12, r2, #3 ");
	asm("bne hash_unal ");
	asm("2: ");
	asm("ldr r12, [r2], #4 ");
	asm("subs r1, r1, #4 ");
	asm("eor r0, r0, r12 ");
	asm("umull r0, r12, r3, r0 ");
	asm("bcs 2b ");
	asm("1: ");
	asm("adds r1, r1, #4 ");
	__JUMP(eq,lr);
	asm("4: ");
	asm("ldrb r12, [r2], #1 ");
	asm("cmp r1, #2 ");
	asm("eor r0, r0, r12 ");
	asm("ldrcsb r12, [r2], #1 ");
	asm("eorcs r0, r0, r12, lsl #8 ");
	asm("ldrhib r12, [r2], #1 ");
	asm("eorhi r0, r0, r12, lsl #16 ");
	asm("umull r0, r12, r3, r0 ");
	__JUMP(,lr);

	asm("hash_unal: ");
	asm("bic r2, r2, #3 ");
	asm("stmfd sp!, {r4,r5,lr} ");
	asm("mov r12, r12, lsl #3 ");
	asm("rsb r14, r12, #32 ");
	asm("ldr r4, [r2], #4 ");
	asm("3: ");
	asm("eor r0, r0, r4, lsr r12 ");
	asm("ldr r4, [r2], #4 ");
	asm("subs r1, r1, #4 ");
	asm("eor r0, r0, r4, lsl r14 ");
	asm("umull r0, r5, r3, r0 ");
	asm("bcs 3b ");
	asm("adds r1, r1, #4 ");
	asm("ldmfd sp!, {r4,r5,lr} ");
	asm("subne r2, r2, #4 ");
	asm("addne r2, r2, r12, lsr #3 ");
	asm("bne 4b ");
	__JUMP(,lr);
	}

// Hash a 16 bit string at aPtr, length aLen bytes.
__NAKED__ TUint32 DefaultWStringHash(const TUint16* /*aPtr*/, TInt /*aLen*/)
	{
	asm("str lr, [sp, #-4]! ");
	asm("ldr r3, one_over_phi ");
	asm("subs r1, r1, #8 ");
	asm("mov r2, r0 ");
	asm("mov r0, #0 ");
	asm("blo 1f ");
	asm("ands r12, r2, #3 ");
	asm("bne whash_unal ");
	asm("2: ");
	asm("ldmia r2!, {r12,r14} ");
	asm("subs r1, r1, #8 ");
	asm("eor r0, r0, r12 ");
	asm("eor r0, r0, r14, ror #24 ");
	asm("umull r0, r12, r3, r0 ");
	asm("bcs 2b ");
	asm("1: ");
	asm("adds r1, r1, #8 ");
	asm("beq 8f ");
	asm("4: ");
	asm("ldrh r12, [r2], #2 ");
	asm("cmp r1, #4 ");
	asm("eor r0, r0, r12 ");
	asm("ldrcsh r12, [r2], #2 ");
	asm("eorcs r0, r0, r12, lsl #16 ");
	asm("ldrhih r12, [r2], #2 ");
	asm("eorhi r0, r0, r12, ror #24 ");
	asm("umull r0, r12, r3, r0 ");
	asm("8: ");
	__POPRET("");

	asm("whash_unal: ");
	asm("add r2, r2, #2 ");				// r2 must be 2 mod 4
	asm("ldr r14, [r2, #-4] ");
	asm("3: ");
	asm("eor r0, r0, r14, lsr #16 ");	// char 0 goes into bytes 0,1
	asm("ldmia r2!, {r12,r14} ");
	asm("subs r1, r1, #8 ");
	asm("eor r0, r0, r12, lsl #16 ");	// char 1 goes into bytes 2,3
	asm("mov r12, r12, lsr #16 ");
	asm("orr r12, r12, r14, lsl #16 ");	// r12 = char3:char2
	asm("eor r0, r0, r12, ror #24 ");	// char 2 into bytes 1,2 ; char 3 into bytes 3,0
	asm("umull r0, r12, r3, r0 ");
	asm("bcs 3b ");
	asm("adds r1, r1, #8 ");
	asm("subne r2, r2, #2 ");
	asm("bne 4b ");
	__POPRET("");
	}


/**
@publishedAll
@released

Calculate a 32 bit hash from a 32 bit integer.

@param	aInt	The integer to be hashed.
@return			The calculated 32 bit hash value.
*/
EXPORT_C __NAKED__ TUint32 DefaultHash::Integer(const TInt& /*aInt*/)
	{
	asm("ldr r0, [r0] ");
	asm("ldr r1, one_over_phi ");
	asm("umull r0, r2, r1, r0 ");
	__JUMP(,lr);
	asm("one_over_phi: ");
	asm(".word 0x9e3779b9 ");
	}


#ifdef __USERSIDE_THREAD_DATA__

/**
@internalComponent

Get a pointer to the thread local user data stored in the thread ID register.
*/
__NAKED__ TLocalThreadData* LocalThreadData()
	{
	GET_RWRW_TID(,r0);
	__JUMP(,lr);	
	}

#endif
