// 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