// Copyright (c) 2010-2010 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\nkern\arm\nklib.cia

// 

//

#include <e32atomics.h>

#include <nklib.h>

#ifdef __SRATIO_MACHINE_CODED__

__NAKED__ void SRatio::Set(TUint32 /*aInt*/, TInt /*aDivisorExp*/)

	{

#ifdef __CPU_ARM_HAS_CLZ

	CLZ(		3,1);						// r3=31-MSB(r1), 32 if r1=0

	asm("add	r2, r2, r3 ");				// r2=shift+aDivisorExp

	asm("movs	r1, r1, lsl r3 ");			// shift r1 left so bit 31=1

	asm("rsb	r2, r2, #0 ");				// r2 = -shift-aDivisorExp

	asm("moveq	r2, #0 ");					// if aInt=0, r2=0

	asm("bicne	r2, r2, #0xff000000 ");		// else clear iSpare fields

	asm("bicne	r2, r2, #0x00ff0000 ");		//

#else

	asm("rsb	r2, r2, #0 ");				// r2 = -aDivisorExp

	asm("cmp	r1, #0x00010000 ");			// if aInt top 16 bits clear ...

	asm("movcc	r1, r1, lsl #16 ");			// ... shift 16 bits left ...

	asm("subcc	r2, r2, #16 ");				// ... and subtract 16 from iX

	asm("cmp	r1, #0x01000000 ");

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

	asm("subcc	r2, r2, #8 ");

	asm("cmp	r1, #0x10000000 ");

	asm("movcc	r1, r1, lsl #4 ");

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

	asm("cmp	r1, #0x40000000 ");

	asm("movcc	r1, r1, lsl #2 ");

	asm("subcc	r2, r2, #2 ");

	asm("cmp	r1, #0x80000000 ");

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

	asm("cmp	r1, #0 ");

	asm("moveq	r2, #0 ");					// if aInt=0, r2=0

	asm("bicne	r2, r2, #0xff000000 ");		// else clear iSpare fields

	asm("bicne	r2, r2, #0x00ff0000 ");		//

#endif

	asm("stmia	r0, {r1,r2} ");				// iM in r1, iX in bottom 16 bits of r2

	__JUMP(,	lr);

	}

__NAKED__ TInt SRatio::Reciprocal()

	{

	asm("ldr	r1, [r0] ");				// r1 = iM

	asm("ldrsh	r12, [r0, #4] ");			// r12 = iX

	asm("rsbs	r2, r1, #0 ");

	asm("beq	0f ");						// divide by zero

	asm("add	r12, r12, #63 ");

	asm("rsb	r12, r12, #0 ");			// r12 = -63 - iX

	asm("addvs	r12, r12, #1 ");			// if iM==0x80000000 r12 = -62 - iX (ratio = 2^(31+iX) so reciprocal = 2^(-31-iX) = 2^(31 + (-62-iX))

	asm("bvs	1f ");						// iM=0x80000000

	// 2^(32+iX) > r > 2^(31+iX)

	// 2^(-32-iX) < 1/r < 2^(-31-iX)

	// 2^(31+(-63-iX)) < 1/r < 2^(31+(-62-iX))

	asm("mov	r2, #0 ");					// accumulates result

	asm("mov	r3, #0x80000000 ");			// 33 bit accumulator in C:R3 initialised to 2^32

	asm("2:		");

	asm("adds	r3, r3, r3 ");

	asm("cmpcc	r3, r1 ");

	asm("subcs	r3, r3, r1 ");				// if C=1 or r3>=r1, r3-=r1

	asm("adcs	r2, r2, r2 ");				// next result bit

	asm("bcc	2b ");						// finished when we have 33 bits (when top bit shifted off)

	asm("movs	r2, r2, lsr #1 ");			// rounding bit into C

	asm("orr	r2, r2, #0x80000000 ");		// top bit back

	asm("adcs	r2, r2, #0 ");				// add rounding bit

	asm("movcs	r2, #0x80000000 ");			// if carry, increment exponent

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

	asm("1:		");

	asm("cmp	r12, #-32768 ");

	asm("blt	9f ");						// underflow

	asm("cmp	r12, #32768 ");

	asm("bge	8f ");						// overflow

	asm("str	r2, [r0] ");				// iM

	asm("strh	r12, [r0, #4] ");			// iX

	asm("mov	r0, #0 ");

	__JUMP(,	lr);

	asm("0:		");

	asm("mov	r0, #%a0" : : "i" ((TInt)KErrDivideByZero));

	__JUMP(,	lr);

	asm("8:		");

	asm("mov	r0, #%a0" : : "i" ((TInt)KErrOverflow));

	__JUMP(,	lr);

	asm("9:		");

	asm("mov	r0, #%a0" : : "i" ((TInt)KErrUnderflow));

	__JUMP(,	lr);

	}

__NAKED__ TInt SRatio::Mult(TUint32& /*aInt32*/)

	{

	asm("ldr	r3, [r0] ");				// r3 = iM

	asm("mov	r12, r0 ");

	asm("ldr	r0, [r1] ");				// r0 = aInt32

	asm("cmp	r3, #0 ");

	asm("cmpne	r0, #0 ");

	asm("beq	0f ");						// result zero

	asm("umull	r2, r3, r0, r3 ");			// r3:r2 = aInt32 * iM (lowest value 0x0000000080000000)

	asm("ldrsh	r12, [r12, #4] ");			// r12 = iX

#ifdef __CPU_ARM_HAS_CLZ

	CLZ(		0, 3);						// r0 = number of leading zeros in r3:r2 (can't be >32)

#else

	asm("str	r12, [sp, #-4]! ");

	asm("movs	r12, r3 ");

	asm("mov	r0, #0 ");

	asm("cmp	r12, #0x00010000 ");

	asm("movcc	r12, r12, lsl #16 ");

	asm("addcc	r0, r0, #16 ");

	asm("cmp	r12, #0x01000000 ");

	asm("movcc	r12, r12, lsl #8 ");

	asm("addcc	r0, r0, #8 ");

	asm("cmp	r12, #0x10000000 ");

	asm("movcc	r12, r12, lsl #4 ");

	asm("addcc	r0, r0, #4 ");

	asm("cmp	r12, #0x40000000 ");

	asm("movcc	r12, r12, lsl #2 ");

	asm("addcc	r0, r0, #2 ");

	asm("cmp	r12, #0 ");

	asm("ldr	r12, [sp], #4 ");			// r12 = iX

	asm("addgt	r0, r0, #1 ");

	asm("moveq	r0, #32 ");					// r0 = number of leading zeros in r3:r2 (can't be >32)

#endif

	asm("rsb	r0, r0, #63 ");				// bit number of most significant bit

	asm("add	r0, r0, r12 ");				// bit number of most significant bit after exponent shift

	asm("cmp	r0, #32 ");

	asm("bge	8f ");						// overflow

	asm("cmp	r0, #-1 ");

	asm("blt	9f ");						// underflow

	asm("adds	r12, r12, #32 ");			// shift needed to get result into top 32 bits (>0 left, <0 right)

	asm("beq	1f ");						// no shift

	asm("blt	2f ");						// right shift

	asm("rsb	r0, r12, #32 ");

	asm("mov	r3, r3, lsl r12 ");

	asm("orr	r3, r3, r2, lsr r0 ");

	asm("mov	r2, r2, lsl r12 ");			// r3:r2 <<= r12

	asm("b		1f ");

	asm("2:		");

	asm("rsb	r12, r12, #0 ");

	asm("rsb	r0, r12, #32 ");

	asm("mov	r2, r2, lsr r12 ");

	asm("orr	r2, r2, r3, lsl r0 ");

	asm("mov	r3, r3, lsr r12 ");			// r3:r2 >>= r12

	asm("1:		");

	asm("adds	r2, r2, r2 ");				// rounding

	asm("adcs	r3, r3, #0 ");

	asm("bcs	8f ");						// overflow

	asm("beq	9f ");						// underflow

	asm("mov	r0, #0 ");

	asm("str	r3, [r1] ");

	__JUMP(,	lr);

	asm("0:		");

	asm("mov	r0, #0 ");

	asm("str	r0, [r1] ");

	__JUMP(,	lr);

	asm("8:		");

	asm("mvn	r0, #0 ");

	asm("str	r0, [r1] ");

	asm("mov	r0, #%a0" : : "i" ((TInt)KErrOverflow));

	__JUMP(,	lr);

	asm("9:		");

	asm("mov	r0, #0 ");

	asm("str	r0, [r1] ");

	asm("mov	r0, #%a0" : : "i" ((TInt)KErrUnderflow));

	__JUMP(,	lr);

	}

//TInt SRatio::Mult(TUint64& aInt64)

//	{

//	}

#endif