diff -r 000000000000 -r a41df078684a kernel/eka/euser/us_gcc.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/euser/us_gcc.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,473 @@
+// 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\us_gcc.cpp
+// 
+//
+
+#include "us_std.h"
+#include <e32math.h>
+
+extern "C" {
+
+EXPORT_C TInt64 __fixsfdi(TReal32 a1)
+//
+// Convert float to long long
+//
+	{
+	const TRealX f(a1);
+	const TInt64 ret = f;
+	return ret;
+	}
+
+}	// end of extern "C" declaration
+
+#ifndef __REALS_MACHINE_CODED__
+LOCAL_C void MathException(TInt aErrType) 
+//
+// Decides on type of maths exception according to error and raises exception.
+// Added by AnnW, December 1996
+//
+	{
+
+	TExcType excType=EExcGeneral;
+
+	switch (aErrType)
+		{
+	case KErrArgument:				// error due to invalid operation
+		excType=EExcFloatInvalidOperation;
+		break;
+	case KErrDivideByZero:
+		excType=EExcFloatDivideByZero;
+		break;
+	case KErrOverflow:
+		excType=EExcFloatOverflow;
+		break;
+	case KErrUnderflow:
+		excType=EExcFloatUnderflow;
+		break;
+/*
+	// also errors due to inexact result
+	case KErrInexact:		// const not defined yet
+		excType=EExcFloatInexact;
+		break;
+*/
+	
+	default:
+		// Unknown error
+		Panic(EMathUnknownError);
+		}
+
+	User::RaiseException(excType);
+	}
+
+EXPORT_C TReal32 __addsf3(TReal32 a1,TReal32 a2)
+//
+// Add two floats
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal32 trg;
+	x1.Add(res,x2);	// need not check error because no underflow and others will not be lost in conversion
+	TInt ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+
+	return(trg);
+    }
+
+EXPORT_C TReal64 __adddf3(TReal64 a1,TReal64 a2)
+//
+// Add two doubles
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal64 trg;
+	x1.Add(res,x2);	// need not check error because no underflow and others will not be lost in conversion
+	TInt ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+
+	return(trg);
+    }
+
+EXPORT_C TReal32 __subsf3(TReal32 a1,TReal32 a2)
+//
+// Subtract two floats
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal32 trg;
+	x1.Sub(res,x2);	// need not check error because no underflow and others will not be lost in conversion
+	TInt ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+
+	return(trg);
+	}
+
+EXPORT_C TReal64 __subdf3(TReal64 a1,TReal64 a2)
+//
+// Subtract two doubles
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal64 trg;
+	x1.Sub(res,x2);	// need not check error because no underflow and others will not be lost in conversion
+	TInt ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+
+	return(trg);    
+    }
+
+EXPORT_C TInt __cmpsf3(TReal32 a1,TReal32 a2)
+//
+// Compare two floats
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    if (x1<x2)
+        return(-1);
+    if (x1>x2)
+        return(1);
+    return(0);
+    }
+
+EXPORT_C TInt __cmpdf3(TReal64 a1,TReal64 a2)
+//
+// Compare two doubles
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    if (x1<x2)
+        return(-1);
+    if (x1>x2)
+        return(1);
+    return(0);
+    }
+
+EXPORT_C TInt __eqsf2(TReal32 a1,TReal32 a2)
+//
+// Compare if two floats are equal
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return (x1==x2 ? 0 : 1);
+    }
+
+EXPORT_C TInt __eqdf2(TReal64 a1,TReal64 a2)
+//
+// Compare if two doubles are equal
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return (x1==x2 ? 0 : 1);
+    }
+
+EXPORT_C TInt __nesf2(TReal32 a1,TReal32 a2)
+//
+// Compare if two floats are not equal
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1!=x2 ? 1 : 0);
+    }
+
+EXPORT_C TInt __nedf2(TReal64 a1,TReal64 a2)
+//
+// Compare if two doubles are not equal
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1!=x2 ? 1 : 0);
+    }
+
+EXPORT_C TInt __gtsf2(TReal32 a1,TReal32 a2)
+//
+// Compare if one float is greater than another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1>x2 ? +1 : -1);
+    }
+
+EXPORT_C TInt __gtdf2(TReal64 a1,TReal64 a2)
+//
+// Compare if one double is greater than another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1>x2 ? +1 : -1);
+    }
+
+EXPORT_C TInt __gesf2(TReal32 a1,TReal32 a2)
+//
+// Compare if one float is greater than or equal to another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1>=x2 ? 1 : -1);
+    }
+
+EXPORT_C TInt __gedf2(TReal64 a1,TReal64 a2)
+//
+// Compare if one double is greater than or equal to another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1>=x2 ? 1 : -1);
+    }
+
+EXPORT_C TInt __ltsf2(TReal32 a1,TReal32 a2)
+//
+// Compare if one float is less than another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1<x2 ? -1 : +1);
+    }
+
+EXPORT_C TInt __ltdf2(TReal64 a1,TReal64 a2)
+//
+// Compare if one double is less than another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1<x2 ? -1 : +1);
+    }
+
+EXPORT_C TInt __lesf2(TReal32 a1,TReal32 a2)
+//
+// Compare if one float is less than or equal to another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1<=x2 ? -1 : +1);
+    }
+
+EXPORT_C TInt __ledf2(TReal64 a1,TReal64 a2)
+//
+// Compare if one double is less than or equal to another
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+    return(x1<=x2 ? -1 : +1);
+    }
+
+EXPORT_C TReal32 __mulsf3(TReal32 a1,TReal32 a2)
+//
+// Multiply two floats
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal32 trg;
+	TInt ret=x1.Mult(res,x2);
+	if (ret==KErrNone)		// must check this because if underflow, error is lost in conversion
+		ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+	
+	return((TReal32)res);
+    }
+
+EXPORT_C TReal64 __muldf3(TReal64 a1,TReal64 a2)
+//
+// Multiply two doubles
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal64 trg;
+	TInt ret=x1.Mult(res,x2);
+	if (ret==KErrNone)		// must check this because if underflow, error is lost in conversion
+		ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+
+	return((TReal64)res);
+    }
+
+EXPORT_C TReal32 __divsf3(TReal32 a1,TReal32 a2)
+//
+// Divide two floats
+//
+    {
+
+    TRealX x1=a1;
+    TRealX x2=a2;
+
+	TRealX res;
+	TReal32 trg;
+	TInt ret=x1.Div(res,x2);
+	if (ret==KErrNone)		// must check this because if underflow, error is lost in conversion
+		ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+
+	return((TReal32)res);
+    }
+
+EXPORT_C TReal64 __divdf3(TReal64 a1,TReal64 a2)
+	//
+	// Divide two doubles
+	//
+	{
+
+	TRealX x1=a1;
+	TRealX x2=a2;
+
+	TRealX res;
+	TReal64 trg;
+	TInt ret=x1.Div(res,x2);
+	if (ret==KErrNone)		// must check this because if underflow, error is lost in conversion
+		ret=res.GetTReal(trg);
+	if (ret!=KErrNone)
+		MathException(ret);
+	
+	return((TReal64)res);
+	}
+
+EXPORT_C TReal32 __negsf2(TReal32 a1)
+//
+// Negate a float
+//
+    {
+
+    TRealX x1=a1;
+    return((TReal32)-x1);
+    }
+
+EXPORT_C TReal64 __negdf2(TReal64 a1)
+//
+// Negate a double
+//
+    {
+
+    TRealX x1=a1;
+    return((TReal64)-x1);
+    }
+
+EXPORT_C TReal32 __floatsisf(TInt a1)
+//
+// Convert int to float
+//
+    {
+
+    return((TReal32)TRealX(a1));
+    }
+
+EXPORT_C TReal64 __floatsidf(TInt a1)
+//
+// Convert int to double
+//
+    {
+
+    return((TReal64)TRealX(a1));
+    }
+
+EXPORT_C TInt __fixsfsi(TReal32 a1)
+//
+// Convert float to int
+//
+    {
+
+    return((TInt)TRealX(a1));
+    }
+
+EXPORT_C TInt __fixdfsi(TReal64 a1)
+//
+// Convert double to int
+//
+    {
+
+    return((TInt)TRealX(a1));
+    }
+
+EXPORT_C TReal64 __extendsfdf2(TReal32 a1)
+//
+// Convert a float to a double
+//
+    {
+
+    return((TReal64)TRealX(a1));
+    }
+
+EXPORT_C TReal32 __truncdfsf2(TReal64 a1)
+//
+// Convert a double to a float
+// Raises an exception if conversion results in an error
+//
+    {
+
+	TRealX x1=a1;
+
+	TInt ret;
+	TReal32 trg;
+	if ((ret=x1.GetTReal(trg))!=KErrNone)
+		MathException(ret);
+
+    return(trg);
+    }
+#endif //__REALS_MACHINE_CODED__