Convert Kernelhwsrv package from SFL to EPL
kernel\eka\compsupp is subject to the ARM EABI LICENSE
userlibandfileserver\fatfilenameconversionplugins\unicodeTables is subject to the Unicode license
kernel\eka\kernel\zlib is subject to the zlib license
// 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__ 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
}
// 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