--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/euser/epoc/arm/uc_gcc.cia Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,146 @@
+// 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_gcc.cia
+//
+//
+
+#include <u32std.h>
+#include <e32math.h>
+#include "uc_std.h"
+
+extern "C" {
+EXPORT_C __NAKED__ long long __fixdfdi(double /*aVal*/)
+ {
+ // r0:r1 contains argument, return result in r1:r0
+#ifdef __DOUBLE_WORDS_SWAPPED__
+ asm("mov r2, r0 "); // save sign
+#else
+ asm("mov r2, r1 "); // save sign
+ asm("mov r1, r0 ");
+ asm("mov r0, r2 ");
+#endif
+ asm("bic r0, r0, #0x80000000 "); // remove sign bit from r0
+ asm("mov r3, #0x400 "); // r3=0x43E = exponent of 2^63
+ asm("orr r3, r3, #0x3E ");
+ asm("subs r3, r3, r0, lsr #20 "); // r3=0x43E-exponent = number of right shifts needed
+ asm("ble 1f "); // branch to saturate result if exp>=0x43E
+ asm("cmp r3, #63 ");
+ asm("bgt 2f "); // branch to produce zero result if exp<0x3FF
+ asm("mov r12, r0, lsl #11 "); // left justify mantissa in r1:r0
+ asm("orr r12, r12, r1, lsr #21 ");
+ asm("mov r0, r1, lsl #11 ");
+ asm("orr r1, r12, #0x80000000 "); // put in implied integer bit
+ asm("cmp r3, #32 "); // check if >=32 shifts needed
+ asm("subge r3, r3, #32 "); // if so reduce count by 32
+ asm("movge r0, r1, lsr r3 "); // and shift right by (32+r3)
+ asm("movge r1, #0 ");
+ asm("rsblt r12, r3, #32 "); // else shift right by r3
+ asm("movlt r0, r0, lsr r3 ");
+ asm("orrlt r0, r0, r1, lsl r12 ");
+ asm("movlt r1, r1, lsr r3 ");
+ asm("movs r2, r2 "); // test sign bit
+ __JUMP(pl,lr); // if +ve, finished
+ asm("rsbs r0, r0, #0 "); // if -ve, negate
+ asm("rsc r1, r1, #0 ");
+ __JUMP(,lr);
+ asm("2: ");
+ asm("mov r0, #0 ");
+ asm("mov r1, #0 ");
+ __JUMP(,lr); // return 0
+ asm("1: "); // produce saturated result
+ asm("mvn r1, r2, asr #32 "); // if +ve, r1=FFFFFFFF else r1=0
+ asm("mov r0, r1 "); //
+ asm("eor r1, r1, #0x80000000 "); // if +ve, r1:r0=7FFFFFFF FFFFFFFF else r1:r0=80000000 00000000
+ __JUMP(,lr);
+ }
+
+EXPORT_C __NAKED__ double __floatdidf(long long /*a*/)
+//
+// Convert 64-bit signed integer to double
+//
+ {
+ // r1:r0 = input, return output in r0,r1
+ asm("mov r2, #0x40000000 "); // r2 will hold result exponent
+ asm("and r12, r1, #0x80000000 "); // save sign in r12
+ asm("cmp r1, #0 "); // test for MS word negative or zero
+ asm("orr r2, r2, #0x01E00000 "); // r2=0x41E=exponent of 2^31
+ asm("bpl 1f "); // skip if +
+ asm("rsbs r0, r0, #0 "); // else negate
+ asm("rscs r1, r1, #0 ");
+ asm("1: ");
+ asm("bne 2f "); // branch if ms word nonzero
+ asm("cmp r0, #0 "); // check if ls word also zero
+ __JUMP(eq,lr);
+ asm("cmp r0, #0x10000 "); // normalise r1 and adjust exponent
+ asm("movcc r0, r0, lsl #16 ");
+ asm("subcc r2, r2, #0x01000000 ");
+ asm("cmp r0, #0x1000000 ");
+ asm("movcc r0, r0, lsl #8 ");
+ asm("subcc r2, r2, #0x00800000 ");
+ asm("cmp r0, #0x10000000 ");
+ asm("movcc r0, r0, lsl #4 ");
+ asm("subcc r2, r2, #0x00400000 ");
+ asm("cmp r0, #0x40000000 ");
+ asm("movcc r0, r0, lsl #2 ");
+ asm("subcc r2, r2, #0x00200000 ");
+ asm("cmp r0, #0x80000000 ");
+ asm("movcc r0, r0, lsl #1 ");
+ asm("subcc r2, r2, #0x00100000 ");
+ asm("bic r1, r0, #0x80000000 "); // remove implied integer bit
+ asm("orr r0, r2, r12 "); // sign+exponent into r0
+ asm("orr r0, r0, r1, lsr #11 "); // top 21 mantissa bits into r0
+ asm("mov r1, r1, lsl #21 "); // remaining 11 mantissa bits in r1
+ asm("b 0f ");
+ asm("2: "); // come here if ms word non zero
+ asm("mov r3, #32 "); // r3=32-shift count
+ asm("cmp r1, #0x00010000 ");
+ asm("movcc r1, r1, lsl #16 ");
+ asm("subcc r3, r3, #16 ");
+ asm("cmp r1, #0x01000000 ");
+ asm("movcc r1, r1, lsl #8 ");
+ asm("subcc r3, r3, #8 ");
+ asm("cmp r1, #0x10000000 ");
+ asm("movcc r1, r1, lsl #4 ");
+ asm("subcc r3, r3, #4 ");
+ asm("cmp r1, #0x40000000 ");
+ asm("movcc r1, r1, lsl #2 ");
+ asm("subcc r3, r3, #2 ");
+ asm("cmp r1, #0x80000000 ");
+ asm("movcc r1, r1, lsl #1 ");
+ asm("subcc r3, r3, #1 ");
+ asm("add r2, r2, r3, lsl #20 "); // r2 now holds result exponent
+ asm("orr r1, r1, r0, lsr r3 "); // normalise r1:r0
+ asm("rsb r3, r3, #32 ");
+ asm("mov r0, r0, lsl r3 ");
+ asm("mov r3, r0, lsl #21 "); // rounding bits into r3
+ asm("cmp r3, #0x80000000 "); // C=1 to round up or halfway, C=0 to round down
+ asm("moveqs r3, r0, lsr #12 "); // if exactly half-way, carry=LSB of mantissa
+ asm("addcss r0, r0, #0x800 "); // if C=1, round up
+ asm("adcs r1, r1, #0 ");
+ asm("addcs r2, r2, #0x00100000 "); // if carry, increment exponent
+ asm("bic r3, r1, #0x80000000 "); // remove implied integer bit
+ asm("mov r1, r0, lsr #11 "); // shift mantissa down to correct position
+ asm("orr r1, r1, r3, lsl #21 ");
+ asm("orr r0, r2, r3, lsr #11 "); // and put in exponent
+ asm("orr r0, r0, r12 "); // put in sign bit
+ asm("0: ");
+#ifndef __DOUBLE_WORDS_SWAPPED__
+ asm("mov r2, r1 "); // save sign
+ asm("mov r1, r0 ");
+ asm("mov r0, r2 ");
+#endif
+ __JUMP(,lr);
+ }
+}
+