testfloat: Drop the 2a pin and use meta-oe's TestFloat 3e

The bundled 2a recipe cannot build on any current toolchain: its SPE
patch calls __builtin_spe_mfspefscr, removed in GCC 9, and includes
bits/nan.h, removed in glibc 2.26. qoriq-base.inc is included by the
arm, arm64 and ppc configs, so the pin also blocked meta-oe's portable
testfloat_3e on machines 2a could never build for anyway. Tested with
bitbake testfloat on p2020rdb: 3e builds and ships five binaries.

Signed-off-by: Luciano Dittgen <luciano.dittgen@ossystems.com.br>
(cherry picked from commit 75244dac69e48dbfdbfbae85e4fbb24c37d3b4de)

5 files changed, 0 insertions, 3190 deletions

diff --git a/conf/machine/include/qoriq-base.inc b/conf/machine/include/qoriq-base.inc
index 4a42a8bd3..b71f3a580 100644
--- a/conf/machine/include/qoriq-base.inc
+++ b/conf/machine/include/qoriq-base.inc
@@ -6,7 +6,6 @@ PREFERRED_PROVIDER_u-boot-tools-native ??= "u-boot-tools-native"
 PREFERRED_PROVIDER_u-boot-mkimage-native ??= "u-boot-tools-native"
 PREFERRED_PROVIDER_u-boot-mkimage ??= "u-boot-tools"
 PREFERRED_PROVIDER_nativesdk-u-boot-mkimage ??= "nativesdk-u-boot-tools"
-PREFERRED_VERSION_testfloat = "2a"
 
 SOC_DEFAULT_IMAGE_FSTYPES = "tar.gz"
 SOC_DEFAULT_IMAGE_FSTYPES:append:ls1043a = " wic.bz2"
diff --git a/recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch b/recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch
deleted file mode 100644
index 51a0da191..000000000
--- a/recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch
+++ /dev/null
@@ -1,1428 +0,0 @@
-This patch adds PowerPC support in SoftFloat.
-
-Upstream-Status: Pending
-Signed-off-by: Ebony Zhu <ebony.zhu@freescale.com>
-Signed-off-by: Liu Yu <Yu.Liu@freescale.com>
----
- SoftFloat-2b/processors/powerpc-GCC.h              |   87 ++++
- SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile |   26 ++
- SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h |   55 +++
- .../bits32/powerpc-GCC/softfloat-specialize        |  252 ++++++++++++
- .../softfloat/bits32/powerpc-GCC/softfloat.h       |  155 +++++++
- SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile |   24 ++
- SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h |   55 +++
- .../bits64/powerpc-GCC/softfloat-specialize        |  422 ++++++++++++++++++++
- .../softfloat/bits64/powerpc-GCC/softfloat.h       |  269 +++++++++++++
- 9 files changed, 1345 insertions(+), 0 deletions(-)
- create mode 100644 SoftFloat-2b/processors/powerpc-GCC.h
- create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile
- create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h
- create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize
- create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h
- create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile
- create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h
- create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize
- create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h
-
-diff --git a/SoftFloat-2b/processors/powerpc-GCC.h b/SoftFloat-2b/processors/powerpc-GCC.h
-new file mode 100644
-index 0000000..002a786
---- /dev/null
-+++ b/SoftFloat-2b/processors/powerpc-GCC.h
-@@ -0,0 +1,87 @@
-+/*
-+ * This file is derived from processors/386-gcc.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ *
-+ * THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+ * been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+ * RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+ * AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+ * COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+ * EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+ * INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+ * OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+ */
-+
-+/*----------------------------------------------------------------------------
-+| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
-+*----------------------------------------------------------------------------*/
-+#define BIGENDIAN
-+
-+/*----------------------------------------------------------------------------
-+| The macro `BITS64' can be defined to indicate that 64-bit integer types are
-+| supported by the compiler.
-+*----------------------------------------------------------------------------*/
-+#define BITS32
-+
-+/*----------------------------------------------------------------------------
-+| Each of the following `typedef's defines the most convenient type that holds
-+| integers of at least as many bits as specified.  For example, `uint8' should
-+| be the most convenient type that can hold unsigned integers of as many as
-+| 8 bits.  The `flag' type must be able to hold either a 0 or 1.  For most
-+| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
-+| to the same as `int'.
-+*----------------------------------------------------------------------------*/
-+typedef int flag;
-+typedef int uint8;
-+typedef int int8;
-+typedef int uint16;
-+typedef int int16;
-+typedef unsigned int uint32;
-+typedef signed int int32;
-+#ifdef BITS64
-+typedef unsigned long long int uint64;
-+typedef signed long long int int64;
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Each of the following `typedef's defines a type that holds integers
-+| of _exactly_ the number of bits specified.  For instance, for most
-+| implementation of C, `bits16' and `sbits16' should be `typedef'ed to
-+| `unsigned short int' and `signed short int' (or `short int'), respectively.
-+*----------------------------------------------------------------------------*/
-+typedef unsigned char bits8;
-+typedef signed char sbits8;
-+typedef unsigned short int bits16;
-+typedef signed short int sbits16;
-+typedef unsigned int bits32;
-+typedef signed int sbits32;
-+#ifdef BITS64
-+typedef unsigned long long int bits64;
-+typedef signed long long int sbits64;
-+#endif
-+
-+#ifdef BITS64
-+/*----------------------------------------------------------------------------
-+| The `LIT64' macro takes as its argument a textual integer literal and
-+| if necessary ``marks'' the literal as having a 64-bit integer type.
-+| For example, the GNU C Compiler (`gcc') requires that 64-bit literals be
-+| appended with the letters `LL' standing for `long long', which is `gcc's
-+| name for the 64-bit integer type.  Some compilers may allow `LIT64' to be
-+| defined as the identity macro:  `#define LIT64( a ) a'.
-+*----------------------------------------------------------------------------*/
-+#define LIT64( a ) a##LL
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| The macro `INLINE' can be used before functions that should be inlined.  If
-+| a compiler does not support explicit inlining, this macro should be defined
-+| to be `static'.
-+*----------------------------------------------------------------------------*/
-+#define INLINE extern inline
-+
-diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile
-new file mode 100644
-index 0000000..28f1e33
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile
-@@ -0,0 +1,26 @@
-+
-+PROCESSOR_H = ../../../processors/powerpc-GCC.h
-+SOFTFLOAT_MACROS = ../softfloat-macros
-+
-+OBJ = .o
-+EXE =
-+INCLUDES = -I. -I..
-+COMPILE_C = $(COMPILE_PREFIX)gcc -msoft-float -c -o $@ $(INCLUDES) -I- -O2
-+LINK = $(COMPILE_PREFIX)gcc -o $@
-+
-+ALL: softfloat$(OBJ) timesoftfloat$(EXE)
-+
-+milieu.h: $(PROCESSOR_H)
-+       touch milieu.h
-+
-+softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
-+       $(COMPILE_C) ../softfloat.c
-+
-+timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
-+       $(COMPILE_C) ../timesoftfloat.c
-+
-+timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
-+       $(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
-+
-+clean:
-+       rm -f *.o timesoftfloat$(EXE)
-diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h
-new file mode 100644
-index 0000000..d8b6012
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h
-@@ -0,0 +1,55 @@
-+/*
-+ * This file is derived from softfloat/bits32/386-Win32-GCC/milieu.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*============================================================================
-+
-+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
-+Package, Release 2b.
-+
-+Written by John R. Hauser.  This work was made possible in part by the
-+International Computer Science Institute, located at Suite 600, 1947 Center
-+Street, Berkeley, California 94704.  Funding was partially provided by the
-+National Science Foundation under grant MIP-9311980.  The original version
-+of this code was written as part of a project to build a fixed-point vector
-+processor in collaboration with the University of California at Berkeley,
-+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-+arithmetic/SoftFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) the source code for the derivative work includes prominent notice that
-+the work is derivative, and (2) the source code includes prominent notice with
-+these four paragraphs for those parts of this code that are retained.
-+
-+=============================================================================*/
-+
-+/*----------------------------------------------------------------------------
-+| Include common integer types and flags.
-+*----------------------------------------------------------------------------*/
-+#include "../../../processors/powerpc-GCC.h"
-+
-+/*----------------------------------------------------------------------------
-+| Symbolic Boolean literals.
-+*----------------------------------------------------------------------------*/
-+enum {
-+    FALSE = 0,
-+    TRUE  = 1
-+};
-+
-diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize
-new file mode 100644
-index 0000000..fd2caa4
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize
-@@ -0,0 +1,252 @@
-+/*
-+ * This file is derived from softfloat/bits32/386-Win32-GCC/softfloat-specialize,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*============================================================================
-+
-+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
-+Arithmetic Package, Release 2b.
-+
-+Written by John R. Hauser.  This work was made possible in part by the
-+International Computer Science Institute, located at Suite 600, 1947 Center
-+Street, Berkeley, California 94704.  Funding was partially provided by the
-+National Science Foundation under grant MIP-9311980.  The original version
-+of this code was written as part of a project to build a fixed-point vector
-+processor in collaboration with the University of California at Berkeley,
-+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-+arithmetic/SoftFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) the source code for the derivative work includes prominent notice that
-+the work is derivative, and (2) the source code includes prominent notice with
-+these four paragraphs for those parts of this code that are retained.
-+
-+=============================================================================*/
-+
-+/*----------------------------------------------------------------------------
-+| Underflow tininess-detection mode, statically initialized to default value.
-+| (The declaration in `softfloat.h' must match the `int8' type here.)
-+*----------------------------------------------------------------------------*/
-+int8 float_detect_tininess = float_tininess_after_rounding;
-+
-+/*----------------------------------------------------------------------------
-+| Raises the exceptions specified by `flags'.  Floating-point traps can be
-+| defined here if desired.  It is currently not possible for such a trap
-+| to substitute a result value.  If traps are not implemented, this routine
-+| should be simply `float_exception_flags |= flags;'.
-+*----------------------------------------------------------------------------*/
-+
-+void float_raise( int8 flags )
-+{
-+
-+    float_exception_flags |= flags;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Internal canonical NaN format.
-+*----------------------------------------------------------------------------*/
-+typedef struct {
-+    flag sign;
-+    bits32 high, low;
-+} commonNaNT;
-+
-+/*----------------------------------------------------------------------------
-+| The pattern for a default generated single-precision NaN.
-+*----------------------------------------------------------------------------*/
-+enum {
-+    float32_default_nan = 0xFFFFFFFF
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the single-precision floating-point value `a' is a NaN;
-+| otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float32_is_nan( float32 a )
-+{
-+
-+    return ( 0xFF000000 < (bits32) ( a<<1 ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the single-precision floating-point value `a' is a signaling
-+| NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float32_is_signaling_nan( float32 a )
-+{
-+
-+    return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the single-precision floating-point NaN
-+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
-+| exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static commonNaNT float32ToCommonNaN( float32 a )
-+{
-+    commonNaNT z;
-+
-+    if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
-+    z.sign = a>>31;
-+    z.low = 0;
-+    z.high = a<<9;
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the canonical NaN `a' to the single-
-+| precision floating-point format.
-+*----------------------------------------------------------------------------*/
-+
-+static float32 commonNaNToFloat32( commonNaNT a )
-+{
-+
-+    return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>9 );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Takes two single-precision floating-point values `a' and `b', one of which
-+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
-+| signaling NaN, the invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static float32 propagateFloat32NaN( float32 a, float32 b )
-+{
-+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
-+
-+    aIsNaN = float32_is_nan( a );
-+    aIsSignalingNaN = float32_is_signaling_nan( a );
-+    bIsNaN = float32_is_nan( b );
-+    bIsSignalingNaN = float32_is_signaling_nan( b );
-+    a |= 0x00400000;
-+    b |= 0x00400000;
-+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
-+    if ( aIsNaN ) {
-+        return ( aIsSignalingNaN & bIsNaN ) ? b : a;
-+    }
-+    else {
-+        return b;
-+    }
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| The pattern for a default generated double-precision NaN.  The `high' and
-+| `low' values hold the most- and least-significant bits, respectively.
-+*----------------------------------------------------------------------------*/
-+enum {
-+    float64_default_nan_high = 0xFFFFFFFF,
-+    float64_default_nan_low  = 0xFFFFFFFF
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the double-precision floating-point value `a' is a NaN;
-+| otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float64_is_nan( float64 a )
-+{
-+
-+    return
-+           ( 0xFFE00000 <= (bits32) ( a.high<<1 ) )
-+        && ( a.low || ( a.high & 0x000FFFFF ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the double-precision floating-point value `a' is a signaling
-+| NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float64_is_signaling_nan( float64 a )
-+{
-+
-+    return
-+           ( ( ( a.high>>19 ) & 0xFFF ) == 0xFFE )
-+        && ( a.low || ( a.high & 0x0007FFFF ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the double-precision floating-point NaN
-+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
-+| exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static commonNaNT float64ToCommonNaN( float64 a )
-+{
-+    commonNaNT z;
-+
-+    if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
-+    z.sign = a.high>>31;
-+    shortShift64Left( a.high, a.low, 12, &z.high, &z.low );
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the canonical NaN `a' to the double-
-+| precision floating-point format.
-+*----------------------------------------------------------------------------*/
-+
-+static float64 commonNaNToFloat64( commonNaNT a )
-+{
-+    float64 z;
-+
-+    shift64Right( a.high, a.low, 12, &z.high, &z.low );
-+    z.high |= ( ( (bits32) a.sign )<<31 ) | 0x7FF80000;
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Takes two double-precision floating-point values `a' and `b', one of which
-+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
-+| signaling NaN, the invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static float64 propagateFloat64NaN( float64 a, float64 b )
-+{
-+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
-+
-+    aIsNaN = float64_is_nan( a );
-+    aIsSignalingNaN = float64_is_signaling_nan( a );
-+    bIsNaN = float64_is_nan( b );
-+    bIsSignalingNaN = float64_is_signaling_nan( b );
-+    a.high |= 0x00080000;
-+    b.high |= 0x00080000;
-+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
-+    if ( aIsNaN ) {
-+        return ( aIsSignalingNaN & bIsNaN ) ? b : a;
-+    }
-+    else {
-+        return b;
-+    }
-+
-+}
-+
-diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h
-new file mode 100644
-index 0000000..0015b8e
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h
-@@ -0,0 +1,155 @@
-+/*
-+ * This file is derived from softfloat/bits32/386-Win32-GCC/softfloat.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*============================================================================
-+
-+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
-+Package, Release 2b.
-+
-+Written by John R. Hauser.  This work was made possible in part by the
-+International Computer Science Institute, located at Suite 600, 1947 Center
-+Street, Berkeley, California 94704.  Funding was partially provided by the
-+National Science Foundation under grant MIP-9311980.  The original version
-+of this code was written as part of a project to build a fixed-point vector
-+processor in collaboration with the University of California at Berkeley,
-+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-+arithmetic/SoftFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) the source code for the derivative work includes prominent notice that
-+the work is derivative, and (2) the source code includes prominent notice with
-+these four paragraphs for those parts of this code that are retained.
-+
-+=============================================================================*/
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point types.
-+*----------------------------------------------------------------------------*/
-+typedef bits32 float32;
-+typedef struct {
-+    bits32 high, low;
-+} float64;
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point underflow tininess-detection mode.
-+*----------------------------------------------------------------------------*/
-+extern int8 float_detect_tininess;
-+enum {
-+    float_tininess_after_rounding  = 0,
-+    float_tininess_before_rounding = 1
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point rounding mode.
-+*----------------------------------------------------------------------------*/
-+extern int8 float_rounding_mode;
-+enum {
-+    float_round_nearest_even = 0,
-+    float_round_to_zero      = 1,
-+    float_round_up           = 2,
-+    float_round_down         = 3
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point exception flags.
-+*----------------------------------------------------------------------------*/
-+/*
-+extern int8 float_exception_flags;
-+enum {
-+    float_flag_inexact   =  1,
-+    float_flag_underflow =  2,
-+    float_flag_overflow  =  4,
-+    float_flag_divbyzero =  8,
-+    float_flag_invalid   = 16
-+};
-+*/
-+
-+extern int8 float_exception_flags;
-+enum {
-+    float_flag_inexact   =  16,
-+    float_flag_underflow =  2,
-+    float_flag_overflow  =  1,
-+    float_flag_divbyzero =  4,
-+    float_flag_invalid   = 8
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Routine to raise any or all of the software IEC/IEEE floating-point
-+| exception flags.
-+*----------------------------------------------------------------------------*/
-+void float_raise( int8 );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE integer-to-floating-point conversion routines.
-+*----------------------------------------------------------------------------*/
-+float32 int32_to_float32( int32 );
-+float64 int32_to_float64( int32 );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE single-precision conversion routines.
-+*----------------------------------------------------------------------------*/
-+int32 float32_to_int32( float32 );
-+int32 float32_to_int32_round_to_zero( float32 );
-+float64 float32_to_float64( float32 );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE single-precision operations.
-+*----------------------------------------------------------------------------*/
-+float32 float32_round_to_int( float32 );
-+float32 float32_add( float32, float32 );
-+float32 float32_sub( float32, float32 );
-+float32 float32_mul( float32, float32 );
-+float32 float32_div( float32, float32 );
-+float32 float32_rem( float32, float32 );
-+float32 float32_sqrt( float32 );
-+flag float32_eq( float32, float32 );
-+flag float32_le( float32, float32 );
-+flag float32_lt( float32, float32 );
-+flag float32_eq_signaling( float32, float32 );
-+flag float32_le_quiet( float32, float32 );
-+flag float32_lt_quiet( float32, float32 );
-+flag float32_is_signaling_nan( float32 );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE double-precision conversion routines.
-+*----------------------------------------------------------------------------*/
-+int32 float64_to_int32( float64 );
-+int32 float64_to_int32_round_to_zero( float64 );
-+float32 float64_to_float32( float64 );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE double-precision operations.
-+*----------------------------------------------------------------------------*/
-+float64 float64_round_to_int( float64 );
-+float64 float64_add( float64, float64 );
-+float64 float64_sub( float64, float64 );
-+float64 float64_mul( float64, float64 );
-+float64 float64_div( float64, float64 );
-+float64 float64_rem( float64, float64 );
-+float64 float64_sqrt( float64 );
-+flag float64_eq( float64, float64 );
-+flag float64_le( float64, float64 );
-+flag float64_lt( float64, float64 );
-+flag float64_eq_signaling( float64, float64 );
-+flag float64_le_quiet( float64, float64 );
-+flag float64_lt_quiet( float64, float64 );
-+flag float64_is_signaling_nan( float64 );
-+
-diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile
-new file mode 100644
-index 0000000..a5e2cc7
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile
-@@ -0,0 +1,24 @@
-+
-+PROCESSOR_H = ../../../processors/powerpc-GCC.h
-+SOFTFLOAT_MACROS = ../softfloat-macros
-+
-+OBJ = .o
-+EXE =
-+INCLUDES = -I. -I..
-+COMPILE_C = $(COMPILE_PREFIX) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2
-+LINK = $(COMPILE_PREFIX) -o $@
-+
-+ALL: softfloat$(OBJ) timesoftfloat$(EXE)
-+
-+milieu.h: $(PROCESSOR_H)
-+       touch milieu.h
-+
-+softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c
-+       $(COMPILE_C) ../softfloat.c
-+
-+timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c
-+       $(COMPILE_C) ../timesoftfloat.c
-+
-+timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ)
-+       $(LINK) softfloat$(OBJ) timesoftfloat$(OBJ)
-+
-diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h
-new file mode 100644
-index 0000000..1b66490
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h
-@@ -0,0 +1,55 @@
-+/*
-+ * This file is derived from softfloat/bits64/386-Win32-GCC/milieu.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*============================================================================
-+
-+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
-+Package, Release 2b.
-+
-+Written by John R. Hauser.  This work was made possible in part by the
-+International Computer Science Institute, located at Suite 600, 1947 Center
-+Street, Berkeley, California 94704.  Funding was partially provided by the
-+National Science Foundation under grant MIP-9311980.  The original version
-+of this code was written as part of a project to build a fixed-point vector
-+processor in collaboration with the University of California at Berkeley,
-+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-+arithmetic/SoftFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) the source code for the derivative work includes prominent notice that
-+the work is derivative, and (2) the source code includes prominent notice with
-+these four paragraphs for those parts of this code that are retained.
-+
-+=============================================================================*/
-+
-+/*----------------------------------------------------------------------------
-+| Include common integer types and flags.
-+*----------------------------------------------------------------------------*/
-+#include "../../../processors/SPARC-GCC.h"
-+
-+/*----------------------------------------------------------------------------
-+| Symbolic Boolean literals.
-+*----------------------------------------------------------------------------*/
-+enum {
-+    FALSE = 0,
-+    TRUE  = 1
-+};
-+
-diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize
-new file mode 100644
-index 0000000..b1d0bc8
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize
-@@ -0,0 +1,422 @@
-+/*
-+ * This file is derived from softfloat/bits64/386-Win32-GCC/softfloat-specialize,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*============================================================================
-+
-+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
-+Arithmetic Package, Release 2b.
-+
-+Written by John R. Hauser.  This work was made possible in part by the
-+International Computer Science Institute, located at Suite 600, 1947 Center
-+Street, Berkeley, California 94704.  Funding was partially provided by the
-+National Science Foundation under grant MIP-9311980.  The original version
-+of this code was written as part of a project to build a fixed-point vector
-+processor in collaboration with the University of California at Berkeley,
-+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-+arithmetic/SoftFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) the source code for the derivative work includes prominent notice that
-+the work is derivative, and (2) the source code includes prominent notice with
-+these four paragraphs for those parts of this code that are retained.
-+
-+=============================================================================*/
-+
-+/*----------------------------------------------------------------------------
-+| Underflow tininess-detection mode, statically initialized to default value.
-+| (The declaration in `softfloat.h' must match the `int8' type here.)
-+*----------------------------------------------------------------------------*/
-+int8 float_detect_tininess = float_tininess_before_rounding;
-+
-+/*----------------------------------------------------------------------------
-+| Raises the exceptions specified by `flags'.  Floating-point traps can be
-+| defined here if desired.  It is currently not possible for such a trap
-+| to substitute a result value.  If traps are not implemented, this routine
-+| should be simply `float_exception_flags |= flags;'.
-+*----------------------------------------------------------------------------*/
-+
-+void float_raise( int8 flags )
-+{
-+
-+    float_exception_flags |= flags;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Internal canonical NaN format.
-+*----------------------------------------------------------------------------*/
-+typedef struct {
-+    flag sign;
-+    bits64 high, low;
-+} commonNaNT;
-+
-+/*----------------------------------------------------------------------------
-+| The pattern for a default generated single-precision NaN.
-+*----------------------------------------------------------------------------*/
-+#define float32_default_nan 0x7FFFFFFF
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the single-precision floating-point value `a' is a NaN;
-+| otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float32_is_nan( float32 a )
-+{
-+
-+    return ( 0xFF000000 < (bits32) ( a<<1 ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the single-precision floating-point value `a' is a signaling
-+| NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float32_is_signaling_nan( float32 a )
-+{
-+
-+    return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the single-precision floating-point NaN
-+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
-+| exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static commonNaNT float32ToCommonNaN( float32 a )
-+{
-+    commonNaNT z;
-+
-+    if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
-+    z.sign = a>>31;
-+    z.low = 0;
-+    z.high = ( (bits64) a )<<41;
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the canonical NaN `a' to the single-
-+| precision floating-point format.
-+*----------------------------------------------------------------------------*/
-+
-+static float32 commonNaNToFloat32( commonNaNT a )
-+{
-+
-+    return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Takes two single-precision floating-point values `a' and `b', one of which
-+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
-+| signaling NaN, the invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static float32 propagateFloat32NaN( float32 a, float32 b )
-+{
-+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
-+
-+    aIsNaN = float32_is_nan( a );
-+    aIsSignalingNaN = float32_is_signaling_nan( a );
-+    bIsNaN = float32_is_nan( b );
-+    bIsSignalingNaN = float32_is_signaling_nan( b );
-+    a |= 0x00400000;
-+    b |= 0x00400000;
-+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
-+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| The pattern for a default generated double-precision NaN.
-+*----------------------------------------------------------------------------*/
-+#define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF )
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the double-precision floating-point value `a' is a NaN;
-+| otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float64_is_nan( float64 a )
-+{
-+
-+    return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the double-precision floating-point value `a' is a signaling
-+| NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float64_is_signaling_nan( float64 a )
-+{
-+
-+    return
-+           ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
-+        && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the double-precision floating-point NaN
-+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
-+| exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static commonNaNT float64ToCommonNaN( float64 a )
-+{
-+    commonNaNT z;
-+
-+    if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
-+    z.sign = a>>63;
-+    z.low = 0;
-+    z.high = a<<12;
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the canonical NaN `a' to the double-
-+| precision floating-point format.
-+*----------------------------------------------------------------------------*/
-+
-+static float64 commonNaNToFloat64( commonNaNT a )
-+{
-+
-+    return
-+          ( ( (bits64) a.sign )<<63 )
-+        | LIT64( 0x7FF8000000000000 )
-+        | ( a.high>>12 );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Takes two double-precision floating-point values `a' and `b', one of which
-+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
-+| signaling NaN, the invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static float64 propagateFloat64NaN( float64 a, float64 b )
-+{
-+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
-+
-+    aIsNaN = float64_is_nan( a );
-+    aIsSignalingNaN = float64_is_signaling_nan( a );
-+    bIsNaN = float64_is_nan( b );
-+    bIsSignalingNaN = float64_is_signaling_nan( b );
-+    a |= LIT64( 0x0008000000000000 );
-+    b |= LIT64( 0x0008000000000000 );
-+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
-+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
-+
-+}
-+
-+#ifdef FLOATX80
-+
-+/*----------------------------------------------------------------------------
-+| The pattern for a default generated extended double-precision NaN.  The
-+| `high' and `low' values hold the most- and least-significant bits,
-+| respectively.
-+*----------------------------------------------------------------------------*/
-+#define floatx80_default_nan_high 0x7FFF
-+#define floatx80_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the extended double-precision floating-point value `a' is a
-+| NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag floatx80_is_nan( floatx80 a )
-+{
-+
-+    return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the extended double-precision floating-point value `a' is a
-+| signaling NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag floatx80_is_signaling_nan( floatx80 a )
-+{
-+    bits64 aLow;
-+
-+    aLow = a.low & ~ LIT64( 0x4000000000000000 );
-+    return
-+           ( ( a.high & 0x7FFF ) == 0x7FFF )
-+        && (bits64) ( aLow<<1 )
-+        && ( a.low == aLow );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the extended double-precision floating-
-+| point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, the
-+| invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static commonNaNT floatx80ToCommonNaN( floatx80 a )
-+{
-+    commonNaNT z;
-+
-+    if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
-+    z.sign = a.high>>15;
-+    z.low = 0;
-+    z.high = a.low<<1;
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the canonical NaN `a' to the extended
-+| double-precision floating-point format.
-+*----------------------------------------------------------------------------*/
-+
-+static floatx80 commonNaNToFloatx80( commonNaNT a )
-+{
-+    floatx80 z;
-+
-+    z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
-+    z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Takes two extended double-precision floating-point values `a' and `b', one
-+| of which is a NaN, and returns the appropriate NaN result.  If either `a' or
-+| `b' is a signaling NaN, the invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b )
-+{
-+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
-+
-+    aIsNaN = floatx80_is_nan( a );
-+    aIsSignalingNaN = floatx80_is_signaling_nan( a );
-+    bIsNaN = floatx80_is_nan( b );
-+    bIsSignalingNaN = floatx80_is_signaling_nan( b );
-+    a.low |= LIT64( 0xC000000000000000 );
-+    b.low |= LIT64( 0xC000000000000000 );
-+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
-+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
-+
-+}
-+
-+#endif
-+
-+#ifdef FLOAT128
-+
-+/*----------------------------------------------------------------------------
-+| The pattern for a default generated quadruple-precision NaN.  The `high' and
-+| `low' values hold the most- and least-significant bits, respectively.
-+*----------------------------------------------------------------------------*/
-+#define float128_default_nan_high LIT64( 0x7FFFFFFFFFFFFFFF )
-+#define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
-+| otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float128_is_nan( float128 a )
-+{
-+
-+    return
-+           ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
-+        && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns 1 if the quadruple-precision floating-point value `a' is a
-+| signaling NaN; otherwise returns 0.
-+*----------------------------------------------------------------------------*/
-+
-+flag float128_is_signaling_nan( float128 a )
-+{
-+
-+    return
-+           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
-+        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the quadruple-precision floating-point NaN
-+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
-+| exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static commonNaNT float128ToCommonNaN( float128 a )
-+{
-+    commonNaNT z;
-+
-+    if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );
-+    z.sign = a.high>>63;
-+    shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Returns the result of converting the canonical NaN `a' to the quadruple-
-+| precision floating-point format.
-+*----------------------------------------------------------------------------*/
-+
-+static float128 commonNaNToFloat128( commonNaNT a )
-+{
-+    float128 z;
-+
-+    shift128Right( a.high, a.low, 16, &z.high, &z.low );
-+    z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
-+    return z;
-+
-+}
-+
-+/*----------------------------------------------------------------------------
-+| Takes two quadruple-precision floating-point values `a' and `b', one of
-+| which is a NaN, and returns the appropriate NaN result.  If either `a' or
-+| `b' is a signaling NaN, the invalid exception is raised.
-+*----------------------------------------------------------------------------*/
-+
-+static float128 propagateFloat128NaN( float128 a, float128 b )
-+{
-+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
-+
-+    aIsNaN = float128_is_nan( a );
-+    aIsSignalingNaN = float128_is_signaling_nan( a );
-+    bIsNaN = float128_is_nan( b );
-+    bIsSignalingNaN = float128_is_signaling_nan( b );
-+    a.high |= LIT64( 0x0000800000000000 );
-+    b.high |= LIT64( 0x0000800000000000 );
-+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );
-+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
-+
-+}
-+
-+#endif
-+
-diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h
-new file mode 100644
-index 0000000..5b7cb1c
---- /dev/null
-+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h
-@@ -0,0 +1,269 @@
-+/*
-+ * This file is derived from softfloat/bits64/386-Win32-GCC/softfloat.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*============================================================================
-+
-+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
-+Package, Release 2b.
-+
-+Written by John R. Hauser.  This work was made possible in part by the
-+International Computer Science Institute, located at Suite 600, 1947 Center
-+Street, Berkeley, California 94704.  Funding was partially provided by the
-+National Science Foundation under grant MIP-9311980.  The original version
-+of this code was written as part of a project to build a fixed-point vector
-+processor in collaboration with the University of California at Berkeley,
-+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
-+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
-+arithmetic/SoftFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) the source code for the derivative work includes prominent notice that
-+the work is derivative, and (2) the source code includes prominent notice with
-+these four paragraphs for those parts of this code that are retained.
-+
-+=============================================================================*/
-+
-+/*----------------------------------------------------------------------------
-+| The macro `FLOATX80' must be defined to enable the extended double-precision
-+| floating-point format `floatx80'.  If this macro is not defined, the
-+| `floatx80' type will not be defined, and none of the functions that either
-+| input or output the `floatx80' type will be defined.  The same applies to
-+| the `FLOAT128' macro and the quadruple-precision format `float128'.
-+*----------------------------------------------------------------------------*/
-+#define FLOATX80
-+#define FLOAT128
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point types.
-+*----------------------------------------------------------------------------*/
-+typedef unsigned int float32;
-+typedef unsigned long long float64;
-+#ifdef FLOATX80
-+typedef struct {
-+    unsigned short high;
-+    unsigned long long low;
-+} floatx80;
-+#endif
-+#ifdef FLOAT128
-+typedef struct {
-+    unsigned long long high, low;
-+} float128;
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point underflow tininess-detection mode.
-+*----------------------------------------------------------------------------*/
-+extern int float_detect_tininess;
-+enum {
-+    float_tininess_after_rounding  = 0,
-+    float_tininess_before_rounding = 1
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point rounding mode.
-+*----------------------------------------------------------------------------*/
-+extern int float_rounding_mode;
-+enum {
-+    float_round_nearest_even = 0,
-+    float_round_to_zero      = 1,
-+    float_round_up           = 2,
-+    float_round_down         = 3
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE floating-point exception flags.
-+*----------------------------------------------------------------------------*/
-+extern int float_exception_flags;
-+enum {
-+    float_flag_inexact   =  1,
-+    float_flag_divbyzero =  2,
-+    float_flag_underflow =  4,
-+    float_flag_overflow  =  8,
-+    float_flag_invalid   = 16
-+};
-+
-+/*----------------------------------------------------------------------------
-+| Routine to raise any or all of the software IEC/IEEE floating-point
-+| exception flags.
-+*----------------------------------------------------------------------------*/
-+void float_raise( int );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE integer-to-floating-point conversion routines.
-+*----------------------------------------------------------------------------*/
-+float32 int32_to_float32( int );
-+float64 int32_to_float64( int );
-+#ifdef FLOATX80
-+floatx80 int32_to_floatx80( int );
-+#endif
-+#ifdef FLOAT128
-+float128 int32_to_float128( int );
-+#endif
-+float32 int64_to_float32( long long );
-+float64 int64_to_float64( long long );
-+#ifdef FLOATX80
-+floatx80 int64_to_floatx80( long long );
-+#endif
-+#ifdef FLOAT128
-+float128 int64_to_float128( long long );
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE single-precision conversion routines.
-+*----------------------------------------------------------------------------*/
-+int float32_to_int32( float32 );
-+int float32_to_int32_round_to_zero( float32 );
-+long long float32_to_int64( float32 );
-+long long float32_to_int64_round_to_zero( float32 );
-+float64 float32_to_float64( float32 );
-+#ifdef FLOATX80
-+floatx80 float32_to_floatx80( float32 );
-+#endif
-+#ifdef FLOAT128
-+float128 float32_to_float128( float32 );
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE single-precision operations.
-+*----------------------------------------------------------------------------*/
-+float32 float32_round_to_int( float32 );
-+float32 float32_add( float32, float32 );
-+float32 float32_sub( float32, float32 );
-+float32 float32_mul( float32, float32 );
-+float32 float32_div( float32, float32 );
-+float32 float32_rem( float32, float32 );
-+float32 float32_sqrt( float32 );
-+int float32_eq( float32, float32 );
-+int float32_le( float32, float32 );
-+int float32_lt( float32, float32 );
-+int float32_eq_signaling( float32, float32 );
-+int float32_le_quiet( float32, float32 );
-+int float32_lt_quiet( float32, float32 );
-+int float32_is_signaling_nan( float32 );
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE double-precision conversion routines.
-+*----------------------------------------------------------------------------*/
-+int float64_to_int32( float64 );
-+int float64_to_int32_round_to_zero( float64 );
-+long long float64_to_int64( float64 );
-+long long float64_to_int64_round_to_zero( float64 );
-+float32 float64_to_float32( float64 );
-+#ifdef FLOATX80
-+floatx80 float64_to_floatx80( float64 );
-+#endif
-+#ifdef FLOAT128
-+float128 float64_to_float128( float64 );
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE double-precision operations.
-+*----------------------------------------------------------------------------*/
-+float64 float64_round_to_int( float64 );
-+float64 float64_add( float64, float64 );
-+float64 float64_sub( float64, float64 );
-+float64 float64_mul( float64, float64 );
-+float64 float64_div( float64, float64 );
-+float64 float64_rem( float64, float64 );
-+float64 float64_sqrt( float64 );
-+int float64_eq( float64, float64 );
-+int float64_le( float64, float64 );
-+int float64_lt( float64, float64 );
-+int float64_eq_signaling( float64, float64 );
-+int float64_le_quiet( float64, float64 );
-+int float64_lt_quiet( float64, float64 );
-+int float64_is_signaling_nan( float64 );
-+
-+#ifdef FLOATX80
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE extended double-precision conversion routines.
-+*----------------------------------------------------------------------------*/
-+int floatx80_to_int32( floatx80 );
-+int floatx80_to_int32_round_to_zero( floatx80 );
-+long long floatx80_to_int64( floatx80 );
-+long long floatx80_to_int64_round_to_zero( floatx80 );
-+float32 floatx80_to_float32( floatx80 );
-+float64 floatx80_to_float64( floatx80 );
-+#ifdef FLOAT128
-+float128 floatx80_to_float128( floatx80 );
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE extended double-precision rounding precision.  Valid
-+| values are 32, 64, and 80.
-+*----------------------------------------------------------------------------*/
-+extern int floatx80_rounding_precision;
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE extended double-precision operations.
-+*----------------------------------------------------------------------------*/
-+floatx80 floatx80_round_to_int( floatx80 );
-+floatx80 floatx80_add( floatx80, floatx80 );
-+floatx80 floatx80_sub( floatx80, floatx80 );
-+floatx80 floatx80_mul( floatx80, floatx80 );
-+floatx80 floatx80_div( floatx80, floatx80 );
-+floatx80 floatx80_rem( floatx80, floatx80 );
-+floatx80 floatx80_sqrt( floatx80 );
-+int floatx80_eq( floatx80, floatx80 );
-+int floatx80_le( floatx80, floatx80 );
-+int floatx80_lt( floatx80, floatx80 );
-+int floatx80_eq_signaling( floatx80, floatx80 );
-+int floatx80_le_quiet( floatx80, floatx80 );
-+int floatx80_lt_quiet( floatx80, floatx80 );
-+int floatx80_is_signaling_nan( floatx80 );
-+
-+#endif
-+
-+#ifdef FLOAT128
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE quadruple-precision conversion routines.
-+*----------------------------------------------------------------------------*/
-+int float128_to_int32( float128 );
-+int float128_to_int32_round_to_zero( float128 );
-+long long float128_to_int64( float128 );
-+long long float128_to_int64_round_to_zero( float128 );
-+float32 float128_to_float32( float128 );
-+float64 float128_to_float64( float128 );
-+#ifdef FLOATX80
-+floatx80 float128_to_floatx80( float128 );
-+#endif
-+
-+/*----------------------------------------------------------------------------
-+| Software IEC/IEEE quadruple-precision operations.
-+*----------------------------------------------------------------------------*/
-+float128 float128_round_to_int( float128 );
-+float128 float128_add( float128, float128 );
-+float128 float128_sub( float128, float128 );
-+float128 float128_mul( float128, float128 );
-+float128 float128_div( float128, float128 );
-+float128 float128_rem( float128, float128 );
-+float128 float128_sqrt( float128 );
-+int float128_eq( float128, float128 );
-+int float128_le( float128, float128 );
-+int float128_lt( float128, float128 );
-+int float128_eq_signaling( float128, float128 );
-+int float128_le_quiet( float128, float128 );
-+int float128_lt_quiet( float128, float128 );
-+int float128_is_signaling_nan( float128 );
-+
-+#endif
-+
--- 
-1.5.4
-
diff --git a/recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch b/recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch
deleted file mode 100644
index 2e9041749..000000000
--- a/recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch
+++ /dev/null
@@ -1,1645 +0,0 @@
-This patch adds PowerPC E500v2 SPE support in TestFloat.
-And it disables the testing for hardware that can not trigger SPE interrupt.
-
-Upstream-Status: Pending
-Signed-off-by: Ebony Zhu <ebony.zhu@freescale.com>
-Signed-off-by: Liu Yu <Yu.Liu@freescale.com>
----
- processors/POWERPC-gcc.h                |   99 +++++
- testfloat/powerpc-linux-gcc/Makefile    |   83 +++++
- testfloat/powerpc-linux-gcc/milieu.h    |   71 ++++
- testfloat/powerpc-linux-gcc/systflags.c |  107 ++++++
- testfloat/powerpc-linux-gcc/systfloat.c |  595 +++++++++++++++++++++++++++++++
- testfloat/powerpc-linux-gcc/systmodes.c |   67 ++++
- testfloat/templates/Makefile            |   18 +-
- testfloat/templates/milieu.h            |    2 +-
- testfloat/testFunction.h                |    2 +-
- testfloat/testLoops.c                   |  216 +++++++++++
- 10 files changed, 1252 insertions(+), 8 deletions(-)
- create mode 100644 processors/POWERPC-gcc.h
- create mode 100644 testfloat/powerpc-linux-gcc/Makefile
- create mode 100644 testfloat/powerpc-linux-gcc/milieu.h
- create mode 100644 testfloat/powerpc-linux-gcc/systflags.c
- create mode 100644 testfloat/powerpc-linux-gcc/systfloat.c
- create mode 100644 testfloat/powerpc-linux-gcc/systmodes.c
-
-diff --git a/processors/POWERPC-gcc.h b/processors/POWERPC-gcc.h
-new file mode 100644
-index 0000000..4201faa
---- /dev/null
-+++ b/processors/POWERPC-gcc.h
-@@ -0,0 +1,99 @@
-+/*
-+ * This file is derived from processors/i386-GCC.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ *
-+ * THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
-+ * been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
-+ * RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
-+ * AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
-+ * COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
-+ * EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
-+ * INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
-+ * OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
-+ */
-+
-+/*
-+-------------------------------------------------------------------------------
-+One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined.
-+-------------------------------------------------------------------------------
-+*/
-+#define BIGENDIAN
-+
-+/*
-+-------------------------------------------------------------------------------
-+The macro `BITS64' can be defined to indicate that 64-bit integer types are
-+supported by the compiler.
-+-------------------------------------------------------------------------------
-+*/
-+#undef BITS64
-+
-+/*
-+-------------------------------------------------------------------------------
-+Each of the following `typedef's defines the most convenient type that holds
-+integers of at least as many bits as specified.  For example, `uint8' should
-+be the most convenient type that can hold unsigned integers of as many as
-+8 bits.  The `flag' type must be able to hold either a 0 or 1.  For most
-+implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed
-+to the same as `int'.
-+-------------------------------------------------------------------------------
-+*/
-+typedef int flag;
-+typedef int uint8;
-+typedef int int8;
-+typedef int uint16;
-+typedef int int16;
-+typedef unsigned int uint32;
-+typedef signed int int32;
-+#ifdef BITS64
-+typedef unsigned long long int uint64;
-+typedef signed long long int int64;
-+#endif
-+
-+/*
-+-------------------------------------------------------------------------------
-+Each of the following `typedef's defines a type that holds integers
-+of _exactly_ the number of bits specified.  For instance, for most
-+implementation of C, `bits16' and `sbits16' should be `typedef'ed to
-+`unsigned short int' and `signed short int' (or `short int'), respectively.
-+-------------------------------------------------------------------------------
-+*/
-+typedef unsigned char bits8;
-+typedef signed char sbits8;
-+typedef unsigned short int bits16;
-+typedef signed short int sbits16;
-+typedef unsigned int bits32;
-+typedef signed int sbits32;
-+#ifdef BITS64
-+typedef unsigned long long int bits64;
-+typedef signed long long int sbits64;
-+#endif
-+
-+#ifdef BITS64
-+/*
-+-------------------------------------------------------------------------------
-+The `LIT64' macro takes as its argument a textual integer literal and
-+if necessary ``marks'' the literal as having a 64-bit integer type.
-+For example, the GNU C Compiler (`gcc') requires that 64-bit literals be
-+appended with the letters `LL' standing for `long long', which is `gcc's
-+name for the 64-bit integer type.  Some compilers may allow `LIT64' to be
-+defined as the identity macro:  `#define LIT64( a ) a'.
-+-------------------------------------------------------------------------------
-+*/
-+#define LIT64( a ) a##LL
-+#endif
-+
-+/*
-+-------------------------------------------------------------------------------
-+The macro `INLINE' can be used before functions that should be inlined.  If
-+a compiler does not support explicit inlining, this macro should be defined
-+to be `static'.
-+-------------------------------------------------------------------------------
-+*/
-+#define INLINE extern inline
-+
-diff --git a/testfloat/powerpc-linux-gcc/Makefile b/testfloat/powerpc-linux-gcc/Makefile
-new file mode 100644
-index 0000000..de50aad
---- /dev/null
-+++ b/testfloat/powerpc-linux-gcc/Makefile
-@@ -0,0 +1,83 @@
-+
-+PROCESSOR_H = ../../processors/POWERPC-gcc.h
-+SOFTFLOAT_VERSION = bits32
-+TARGET = powerpc-GCC
-+SOFTFLOAT_DIR = ../../SoftFloat-2b/softfloat/$(SOFTFLOAT_VERSION)/$(TARGET)
-+
-+OBJ = .o
-+EXE =
-+INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR)
-+
-+COMPILE_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS)
-+
-+COMPILE_C_HARD = $(COMPILE_PREFIX)gcc -c -te500v2 -o $@ $(INCLUDES)
-+
-+COMPILE_SLOWFLOAT_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O
-+
-+LINK = $(COMPILE_PREFIX)gcc -lm -o $@
-+
-+SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h
-+SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ)
-+
-+ALL: testsoftfloat$(EXE) testfloat$(EXE)
-+
-+systmodes$(OBJ): milieu.h systmodes.c
-+       $(COMPILE_C) systmodes.c
-+
-+systflags$(OBJ): milieu.h ../systflags.h systflags.c
-+       $(COMPILE_C) systflags.c
-+
-+systfloat$(OBJ): milieu.h $(SOFTFLOAT_H) ../systfloat.h systfloat.c
-+       $(COMPILE_C_HARD) systfloat.c
-+
-+#------------------------------------------------------------------------------
-+# Probably O.K. below here.
-+#------------------------------------------------------------------------------
-+
-+milieu.h: $(PROCESSOR_H)
-+       touch milieu.h
-+
-+fail$(OBJ): milieu.h ../fail.h
-+       $(COMPILE_C) ../fail.c
-+
-+random$(OBJ): milieu.h ../random.h
-+       $(COMPILE_C) ../random.c
-+
-+testCases$(OBJ): milieu.h ../fail.h ../random.h $(SOFTFLOAT_H) ../testCases.h ../testCases.c
-+       $(COMPILE_C) ../testCases.c
-+
-+writeHex$(OBJ): milieu.h $(SOFTFLOAT_H) ../writeHex.h ../writeHex.c
-+       $(COMPILE_C) ../writeHex.c
-+
-+testLoops$(OBJ): milieu.h $(SOFTFLOAT_H) ../testCases.h ../writeHex.h ../testLoops.h ../testLoops.c
-+       $(COMPILE_C) ../testLoops.c
-+
-+slowfloat$(OBJ): milieu.h $(SOFTFLOAT_H) ../slowfloat.h ../slowfloat-32.c ../slowfloat-64.c ../slowfloat.c
-+       $(COMPILE_SLOWFLOAT_C) ../slowfloat.c
-+
-+testsoftfloat$(OBJ): milieu.h ../fail.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../slowfloat.h ../testsoftfloat.c
-+       $(COMPILE_C) ../testsoftfloat.c
-+
-+testsoftfloat$(EXE): fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) slowfloat$(OBJ) testsoftfloat$(OBJ) systflags$(OBJ) systmodes$(OBJ)
-+       $(LINK) fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) slowfloat$(OBJ) testsoftfloat$(OBJ) systflags$(OBJ) systmodes$(OBJ)
-+
-+testFunction$(OBJ): milieu.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../systmodes.h ../systflags.h ../systfloat.h ../testFunction.h ../testFunction.c
-+       $(COMPILE_C) ../testFunction.c
-+
-+testfloat$(OBJ): milieu.h ../fail.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../systflags.h ../testFunction.h ../testfloat.c
-+       $(COMPILE_C) ../testfloat.c
-+
-+testfloat$(EXE): fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) systmodes$(OBJ) systflags$(OBJ) systfloat$(OBJ) testFunction$(OBJ) testfloat$(OBJ)
-+       $(LINK) fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) systmodes$(OBJ) systflags$(OBJ) systfloat$(OBJ) testFunction$(OBJ) testfloat$(OBJ)
-+
-+$(SOFTFLOAT_OBJ):
-+       make -C $(SOFTFLOAT_DIR)
-+
-+cp: ALL
-+       cp  testsoftfloat$(EXE) ../../test_softfloat$(EXE)
-+       cp  testfloat$(EXE)  ../../test_float$(EXE)
-+
-+clean:
-+       make -C $(SOFTFLOAT_DIR) clean
-+       rm -f *.o testfloat$(EXE) testsoftfloat$(EXE) 
-+       rm -f ../../test_softfloat$(EXE) ../../test_float$(EXE)
-diff --git a/testfloat/powerpc-linux-gcc/milieu.h b/testfloat/powerpc-linux-gcc/milieu.h
-new file mode 100644
-index 0000000..29d2b18
---- /dev/null
-+++ b/testfloat/powerpc-linux-gcc/milieu.h
-@@ -0,0 +1,71 @@
-+/*
-+ * This file is derived from testfloat/386-Win32-gcc/milieu.h,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*
-+===============================================================================
-+
-+This C header file is part of TestFloat, Release 2a, a package of programs
-+for testing the correctness of floating-point arithmetic complying to the
-+IEC/IEEE Standard for Floating-Point.
-+
-+Written by John R. Hauser.  More information is available through the Web
-+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
-+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
-+TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
-+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
-+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) they include prominent notice that the work is derivative, and (2) they
-+include prominent notice akin to these four paragraphs for those parts of
-+this code that are retained.
-+
-+===============================================================================
-+*/
-+
-+/*
-+-------------------------------------------------------------------------------
-+Include common integer types and flags.
-+-------------------------------------------------------------------------------
-+*/
-+#include "../../processors/POWERPC-gcc.h"
-+/*
-+-------------------------------------------------------------------------------
-+If the `BITS64' macro is defined by the processor header file but the
-+version of SoftFloat being used/tested is the 32-bit one (`bits32'), the
-+`BITS64' macro must be undefined here.
-+-------------------------------------------------------------------------------
-+*/
-+
-+#undef BITS64
-+/*
-+-------------------------------------------------------------------------------
-+The macro `LONG_DOUBLE_IS_FLOATX80' can be defined to indicate that the
-+C compiler supports the type `long double' as an extended double-precision
-+format.  Alternatively, the macro `LONG_DOUBLE_IS_FLOAT128' can be defined
-+to indicate that `long double' is a quadruple-precision format.  If neither
-+of these macros is defined, `long double' will be ignored.
-+-------------------------------------------------------------------------------
-+#define LONG_DOUBLE_IS_FLOATX80
-+*/
-+
-+/*
-+-------------------------------------------------------------------------------
-+Symbolic Boolean literals.
-+-------------------------------------------------------------------------------
-+*/
-+enum {
-+    FALSE = 0,
-+    TRUE  = 1
-+};
-+
-diff --git a/testfloat/powerpc-linux-gcc/systflags.c b/testfloat/powerpc-linux-gcc/systflags.c
-new file mode 100644
-index 0000000..c382442
---- /dev/null
-+++ b/testfloat/powerpc-linux-gcc/systflags.c
-@@ -0,0 +1,107 @@
-+/*
-+ * This file is derived from testfloat/386-Win32-gcc/systflags.c,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*
-+===============================================================================
-+
-+This C source file is part of TestFloat, Release 2a, a package of programs
-+for testing the correctness of floating-point arithmetic complying to the
-+IEC/IEEE Standard for Floating-Point.
-+
-+Written by John R. Hauser.  More information is available through the Web
-+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
-+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
-+TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
-+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
-+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) they include prominent notice that the work is derivative, and (2) they
-+include prominent notice akin to these four paragraphs for those parts of
-+this code that are retained.
-+
-+===============================================================================
-+*/
-+
-+#include "milieu.h"
-+#include "systflags.h"
-+#include <fenv.h>
-+#include <stdio.h>
-+#include <math.h>
-+#include <bits/nan.h>
-+#include <bits/inf.h>
-+
-+#ifdef __SPE__
-+
-+#include <spe.h>
-+
-+
-+#define SPE_FINV_ENABLE                (1UL << 5)
-+#define SPE_FDBZ_ENABLE                (1UL << 4)
-+#define SPE_FUNF_ENABLE                (1UL << 3)
-+#define SPE_FOVF_ENABLE                (1UL << 2)
-+
-+#define SPE_FG                 (1UL << 13)
-+#define SPE_FX                 (1UL << 12)
-+#define SPE_FINV               (1UL << 11)
-+#define SPE_FDBZ               (1UL << 10)
-+#define SPE_FUNF               (1UL << 9)
-+#define SPE_FOVF               (1UL << 8)
-+
-+#define SPE_FG_H               (1UL << 29)
-+#define SPE_FX_H               (1UL << 28)
-+#define SPE_FINV_H             (1UL << 27)
-+#define SPE_FDBZ_H             (1UL << 26)
-+#define SPE_FUNF_H             (1UL << 25)
-+#define SPE_FOVF_H             (1UL << 24)
-+
-+static int is_soft_emu = 0;
-+
-+#endif
-+/*
-+-------------------------------------------------------------------------------
-+Clears the system's IEC/IEEE floating-point exception flags.  Returns the
-+previous value of the flags.
-+-------------------------------------------------------------------------------
-+*/
-+extern int rounding;
-+unsigned int spefscr = 0;
-+
-+int8 syst_float_flags_clear( void )
-+{
-+#ifdef TEST_KERNEL_EMU
-+       if( (spefscr & (SPE_FINV | SPE_FINV_H))
-+          || (spefscr & (SPE_FDBZ | SPE_FDBZ_H))
-+          || (spefscr & (SPE_FUNF | SPE_FUNF_H))
-+          || (spefscr & (SPE_FOVF | SPE_FOVF_H))
-+          || (spefscr & (SPE_FX | SPE_FG | SPE_FX_H | SPE_FG_H))){ 
-+               is_soft_emu = 1;
-+       } else {
-+               is_soft_emu = 0;
-+       }
-+#endif 
-+       __builtin_spe_mtspefscr(0x3c|(rounding & 0x3));
-+
-+       return ((spefscr>>17) & 0x1f);
-+}
-+
-+int syst_float_is_soft_emu(void)
-+{
-+       int ret = 0;
-+#ifdef TEST_KERNEL_EMU
-+       ret = is_soft_emu;
-+#endif
-+       return ret;
-+}
-+
-+
-diff --git a/testfloat/powerpc-linux-gcc/systfloat.c b/testfloat/powerpc-linux-gcc/systfloat.c
-new file mode 100644
-index 0000000..8d06f9f
---- /dev/null
-+++ b/testfloat/powerpc-linux-gcc/systfloat.c
-@@ -0,0 +1,595 @@
-+/*
-+ * This file is derived from testfloat/systfloat.c,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*
-+===============================================================================
-+
-+This C source file is part of TestFloat, Release 2a, a package of programs
-+for testing the correctness of floating-point arithmetic complying to the
-+IEC/IEEE Standard for Floating-Point.
-+
-+Written by John R. Hauser.  More information is available through the Web
-+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
-+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
-+TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
-+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
-+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) they include prominent notice that the work is derivative, and (2) they
-+include prominent notice akin to these four paragraphs for those parts of
-+this code that are retained.
-+
-+===============================================================================
-+*/
-+
-+#include <math.h>
-+#include "milieu.h"
-+#include "softfloat.h"
-+#include "systfloat.h"
-+
-+extern unsigned int spefscr;
-+
-+float32 syst_int32_to_float32( int32 a )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = a;
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float64 syst_int32_to_float64( int32 a )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = a;
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
-+
-+floatx80 syst_int32_to_floatx80( int32 a )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) = a;
-+    return z;
-+
-+}
-+
-+#endif
-+
-+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
-+
-+float128 syst_int32_to_float128( int32 a )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) = a;
-+    return z;
-+
-+}
-+
-+#endif
-+
-+#ifdef BITS64
-+
-+float32 syst_int64_to_float32( int64 a )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = a;
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float64 syst_int64_to_float64( int64 a )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = a;
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
-+
-+floatx80 syst_int64_to_floatx80( int64 a )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) = a;
-+    return z;
-+
-+}
-+
-+#endif
-+
-+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
-+
-+float128 syst_int64_to_float128( int64 a )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) = a;
-+    return z;
-+
-+}
-+
-+#endif
-+
-+#endif
-+
-+int32 syst_float32_to_int32_round_to_zero( float32 a )
-+{
-+    int32 z = *( (float *) &a );
-+    spefscr = __builtin_spe_mfspefscr();
-+
-+    return z;
-+
-+}
-+
-+#ifdef BITS64
-+
-+int64 syst_float32_to_int64_round_to_zero( float32 a )
-+{
-+    int64 z = *( (float *) &a );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#endif
-+
-+float64 syst_float32_to_float64( float32 a )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (float *) &a );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
-+
-+floatx80 syst_float32_to_floatx80( float32 a )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) = *( (float *) &a );
-+    return z;
-+
-+}
-+
-+#endif
-+
-+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
-+
-+float128 syst_float32_to_float128( float32 a )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) = *( (float *) &a );
-+    return z;
-+
-+}
-+
-+#endif
-+
-+float32 syst_float32_add( float32 a, float32 b )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (float *) &a ) + *( (float *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float32 syst_float32_sub( float32 a, float32 b )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (float *) &a ) - *( (float *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float32 syst_float32_mul( float32 a, float32 b )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (float *) &a ) * *( (float *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float32 syst_float32_div( float32 a, float32 b )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (float *) &a ) / *( (float *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+flag syst_float32_eq( float32 a, float32 b )
-+{
-+    flag f = ( *( (float *) &a ) == *( (float *) &b ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return f;
-+
-+}
-+
-+flag syst_float32_le( float32 a, float32 b )
-+{
-+    flag f = ( *( (float *) &a ) <= *( (float *) &b ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return f;
-+
-+}
-+
-+flag syst_float32_lt( float32 a, float32 b )
-+{
-+    flag f = ( *( (float *) &a ) < *( (float *) &b ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return f;
-+
-+}
-+
-+int32 syst_float64_to_int32_round_to_zero( float64 a )
-+{
-+    int32 z = *( (double *) &a );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#ifdef BITS64
-+
-+int64 syst_float64_to_int64_round_to_zero( float64 a )
-+{
-+    int64 z = *( (double *) &a );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#endif
-+
-+float32 syst_float64_to_float32( float64 a )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (double *) &a );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
-+
-+floatx80 syst_float64_to_floatx80( float64 a )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) = *( (double *) &a );
-+    return z;
-+
-+}
-+
-+#endif
-+
-+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
-+
-+float128 syst_float64_to_float128( float64 a )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) = *( (double *) &a );
-+    return z;
-+
-+}
-+
-+#endif
-+
-+float64 syst_float64_add( float64 a, float64 b )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (double *) &a ) + *( (double *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float64 syst_float64_sub( float64 a, float64 b )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (double *) &a ) - *( (double *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float64 syst_float64_mul( float64 a, float64 b )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (double *) &a ) * *( (double *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float64 syst_float64_div( float64 a, float64 b )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (double *) &a ) / *( (double *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+float64 syst_float64_sqrt( float64 a )
-+{
-+       /* Ebony
-+    float64 z;
-+
-+    *( (double *) &z ) = sqrt( *( (double *) &a ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+    */
-+
-+}
-+
-+flag syst_float64_eq( float64 a, float64 b )
-+{
-+    flag f = ( *( (double *) &a ) == *( (double *) &b ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return f;
-+
-+}
-+
-+flag syst_float64_le( float64 a, float64 b )
-+{
-+    flag f = ( *( (double *) &a ) <= *( (double *) &b ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return f;
-+
-+}
-+
-+flag syst_float64_lt( float64 a, float64 b )
-+{
-+    flag f = ( *( (double *) &a ) < *( (double *) &b ) );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return f;
-+
-+}
-+
-+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
-+
-+int32 syst_floatx80_to_int32_round_to_zero( floatx80 a )
-+{
-+
-+    return *( (long double *) &a );
-+
-+}
-+
-+#ifdef BITS64
-+
-+int64 syst_floatx80_to_int64_round_to_zero( floatx80 a )
-+{
-+
-+    return *( (long double *) &a );
-+
-+}
-+
-+#endif
-+
-+float32 syst_floatx80_to_float32( floatx80 a )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (long double *) &a );
-+    return z;
-+
-+}
-+
-+float64 syst_floatx80_to_float64( floatx80 a )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (long double *) &a );
-+    return z;
-+
-+}
-+
-+floatx80 syst_floatx80_add( floatx80 a, floatx80 b )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) + *( (long double *) &b );
-+    return z;
-+
-+}
-+
-+floatx80 syst_floatx80_sub( floatx80 a, floatx80 b )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) - *( (long double *) &b );
-+    return z;
-+
-+}
-+
-+floatx80 syst_floatx80_mul( floatx80 a, floatx80 b )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) * *( (long double *) &b );
-+    return z;
-+
-+}
-+
-+floatx80 syst_floatx80_div( floatx80 a, floatx80 b )
-+{
-+    floatx80 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) / *( (long double *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+flag syst_floatx80_eq( floatx80 a, floatx80 b )
-+{
-+
-+    return ( *( (long double *) &a ) == *( (long double *) &b ) );
-+
-+}
-+
-+flag syst_floatx80_le( floatx80 a, floatx80 b )
-+{
-+
-+    return ( *( (long double *) &a ) <= *( (long double *) &b ) );
-+
-+}
-+
-+flag syst_floatx80_lt( floatx80 a, floatx80 b )
-+{
-+
-+    return ( *( (long double *) &a ) < *( (long double *) &b ) );
-+
-+}
-+
-+#endif
-+
-+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
-+
-+int32 syst_float128_to_int32_round_to_zero( float128 a )
-+{
-+
-+    return *( (long double *) &a );
-+
-+}
-+
-+#ifdef BITS64
-+
-+int64 syst_float128_to_int64_round_to_zero( float128 a )
-+{
-+
-+    return *( (long double *) &a );
-+
-+}
-+
-+#endif
-+
-+float32 syst_float128_to_float32( float128 a )
-+{
-+    float32 z;
-+
-+    *( (float *) &z ) = *( (long double *) &a );
-+    return z;
-+
-+}
-+
-+float64 syst_float128_to_float64( float128 a )
-+{
-+    float64 z;
-+
-+    *( (double *) &z ) = *( (long double *) &a );
-+    return z;
-+
-+}
-+
-+float128 syst_float128_add( float128 a, float128 b )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) + *( (long double *) &b );
-+    return z;
-+
-+}
-+
-+float128 syst_float128_sub( float128 a, float128 b )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) - *( (long double *) &b );
-+    return z;
-+
-+}
-+
-+float128 syst_float128_mul( float128 a, float128 b )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) * *( (long double *) &b );
-+    return z;
-+
-+}
-+
-+float128 syst_float128_div( float128 a, float128 b )
-+{
-+    float128 z;
-+
-+    *( (long double *) &z ) =
-+        *( (long double *) &a ) / *( (long double *) &b );
-+    spefscr = __builtin_spe_mfspefscr();
-+    return z;
-+
-+}
-+
-+flag syst_float128_eq( float128 a, float128 b )
-+{
-+
-+    return ( *( (long double *) &a ) == *( (long double *) &b ) );
-+
-+}
-+
-+flag syst_float128_le( float128 a, float128 b )
-+{
-+
-+    return ( *( (long double *) &a ) <= *( (long double *) &b ) );
-+
-+}
-+
-+flag syst_float128_lt( float128 a, float128 b )
-+{
-+
-+    return ( *( (long double *) &a ) < *( (long double *) &b ) );
-+
-+}
-+
-+#endif
-+
-diff --git a/testfloat/powerpc-linux-gcc/systmodes.c b/testfloat/powerpc-linux-gcc/systmodes.c
-new file mode 100644
-index 0000000..143cdea
---- /dev/null
-+++ b/testfloat/powerpc-linux-gcc/systmodes.c
-@@ -0,0 +1,67 @@
-+/*
-+ * This file is derived from testfloat/386-Win32-gcc/systmodes.S,
-+ * the copyright for that material belongs to the original owners.
-+ *
-+ * Additional material and changes where applicable is:
-+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved.
-+ *
-+ * Author: Ebony Zhu,  <ebony.zhu@freescale.com>
-+ *         Yu Liu,     <yu.liu@freescale.com>
-+ */
-+
-+/*
-+===============================================================================
-+
-+This C source file is part of TestFloat, Release 2a, a package of programs
-+for testing the correctness of floating-point arithmetic complying to the
-+IEC/IEEE Standard for Floating-Point.
-+
-+Written by John R. Hauser.  More information is available through the Web
-+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
-+
-+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
-+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
-+TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
-+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
-+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
-+
-+Derivative works are acceptable, even for commercial purposes, so long as
-+(1) they include prominent notice that the work is derivative, and (2) they
-+include prominent notice akin to these four paragraphs for those parts of
-+this code that are retained.
-+
-+===============================================================================
-+*/
-+
-+#include <fenv.h>
-+#include "milieu.h"
-+#include "systmodes.h"
-+/*
-+-------------------------------------------------------------------------------
-+Sets the system's IEC/IEEE floating-point rounding mode.  Also disables all
-+system exception traps.
-+-------------------------------------------------------------------------------
-+*/
-+int rounding;
-+
-+void syst_float_set_rounding_mode( int8 roundingMode )
-+{
-+       (void) fesetround ( roundingMode );
-+       rounding = roundingMode;
-+}
-+
-+/*
-+-------------------------------------------------------------------------------
-+Sets the rounding precision of subsequent extended double-precision
-+operations.  The `precision' argument should be one of 0, 32, 64, or 80.
-+If `precision' is 32, the rounding precision is set equivalent to single
-+precision; else if `precision' is 64, the rounding precision is set
-+equivalent to double precision; else the rounding precision is set to full
-+extended double precision.
-+-------------------------------------------------------------------------------
-+*/
-+void syst_float_set_rounding_precision( int8 precision )
-+{
-+
-+}
-+
-diff --git a/testfloat/templates/Makefile b/testfloat/templates/Makefile
-index f5f3cde..18cffe0 100644
---- a/testfloat/templates/Makefile
-+++ b/testfloat/templates/Makefile
-@@ -1,15 +1,21 @@
- 
--PROCESSOR_H = ../../processors/!!!processor.h
-+#PROCESSOR_H = ../../processors/!!!processor.h
-+PROCESSOR_H = ../../processors/POWERPC-gcc.h
- SOFTFLOAT_VERSION = bits64
--TARGET = !!!target
--SOFTFLOAT_DIR = ../../softfloat/$(SOFTFLOAT_VERSION)/$(TARGET)
-+
-+#TARGET = !!!target
-+TARGET = powerpc-GCC
-+SOFTFLOAT_DIR = ../../../SoftFloat-2b/softfloat/$(SOFTFLOAT_VERSION)/$(TARGET)
- 
- OBJ = .o
- EXE =
- INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR)
--COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
--COMPILE_SLOWFLOAT_C = gcc -c -o $@ $(INCLUDES) -I- -O3
--LINK = gcc -o $@
-+#COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2
-+#COMPILE_SLOWFLOAT_C = gcc -c -o $@ $(INCLUDES) -I- -O3
-+#LINK = gcc -o $@
-+COMPILE_C = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -c -o $@ $(INCLUDES) -I- -O2
-+COMPILE_SLOWFLOAT_C = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -c -o $@ $(INCLUDES) -I- -O3
-+LINK = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -o $@
- 
- SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h
- SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ)
-diff --git a/testfloat/templates/milieu.h b/testfloat/templates/milieu.h
-index 56d3ac4..3214ca8 100644
---- a/testfloat/templates/milieu.h
-+++ b/testfloat/templates/milieu.h
-@@ -28,7 +28,7 @@ this code that are retained.
- Include common integer types and flags.
- -------------------------------------------------------------------------------
- */
--#include "../../processors/!!!processor.h"
-+#include "../../processors/SPARC-gcc.h"
- 
- /*
- -------------------------------------------------------------------------------
-diff --git a/testfloat/testFunction.h b/testfloat/testFunction.h
-index 04bf856..00139a7 100644
---- a/testfloat/testFunction.h
-+++ b/testfloat/testFunction.h
-@@ -126,8 +126,8 @@ extern const flag functionExists[ NUM_FUNCTIONS ];
- enum {
-     ROUND_NEAREST_EVEN = 1,
-     ROUND_TO_ZERO,
--    ROUND_DOWN,
-     ROUND_UP,
-+    ROUND_DOWN,
-     NUM_ROUNDINGMODES
- };
- 
-diff --git a/testfloat/testLoops.c b/testfloat/testLoops.c
-index 8ba92f3..ba05548 100644
---- a/testfloat/testLoops.c
-+++ b/testfloat/testLoops.c
-@@ -488,6 +488,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -539,6 +544,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -592,6 +602,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -647,6 +662,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -702,6 +722,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -753,6 +778,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -806,6 +836,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -861,6 +896,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_int64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -916,6 +956,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -973,6 +1018,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1030,6 +1080,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1087,6 +1142,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1146,6 +1206,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1203,6 +1268,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1260,6 +1330,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32, testCases_b_float32 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1312,6 +1387,25 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float32, testCases_b_float32 );
-         testFlags = testFlagsFunctionPtr();
-+
-+if(testCases_a_float32 == 0x7ffffe && testCases_b_float32 == 0x3f7ffffe)
-+{
-+
-+                writeErrorFound( 10000 - count );
-+                writeInputs_ab_float32();
-+                fputs( "  ", stdout );
-+                writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags );
-+                fflush( stdout );
-+       if (! syst_float_is_soft_emu()){
-+               exit(-1);
-+       }
-+}
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-+        
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1370,6 +1464,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1427,6 +1526,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1484,6 +1588,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1541,6 +1650,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1600,6 +1714,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1657,6 +1776,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1714,6 +1838,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64, testCases_b_float64 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1766,6 +1895,13 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float64, testCases_b_float64 );
-         testFlags = testFlagsFunctionPtr();
-+
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-+
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1826,6 +1962,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1883,6 +2024,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1940,6 +2086,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -1995,6 +2146,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2052,6 +2208,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2109,6 +2270,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2166,6 +2332,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2218,6 +2389,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2280,6 +2456,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2337,6 +2518,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2394,6 +2580,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2449,6 +2640,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2506,6 +2702,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2563,6 +2764,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2620,6 +2826,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128, testCases_b_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
-@@ -2672,6 +2883,11 @@ void
-         (void) testFlagsFunctionPtr();
-         testZ = testFunction( testCases_a_float128, testCases_b_float128 );
-         testFlags = testFlagsFunctionPtr();
-+#ifdef TEST_KERNEL_EMU
-+       if (! syst_float_is_soft_emu()){
-+               continue;
-+       }
-+#endif
-         --count;
-         if ( count == 0 ) {
-             checkEarlyExit();
--- 
-1.5.4
-
diff --git a/recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch b/recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch
deleted file mode 100644
index c6cfaf417..000000000
--- a/recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch
+++ /dev/null
@@ -1,68 +0,0 @@
-From 6c7567e05c28b8cb6c7dc68c278950a32feb6f64 Mon Sep 17 00:00:00 2001
-From: Ting Liu <b28495@freescale.com>
-Date: Wed, 9 May 2012 02:42:57 -0500
-Subject: [PATCH] Yocto: replace $(COMPILE_PREFIX)gcc with $(CC) and remove -te500v2 flags
-
-Upstream-Status: Pending
-Signed-off-by: Ting Liu <b28495@freescale.com>
----
- SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile |    4 ++--
- SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile |    4 ++--
- testfloat/powerpc-linux-gcc/Makefile               |    8 ++++----
- 3 files changed, 8 insertions(+), 8 deletions(-)
-
-diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile
-index 28f1e33..4098048 100644
---- a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile
-+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile
-@@ -5,8 +5,8 @@ SOFTFLOAT_MACROS = ../softfloat-macros
- OBJ = .o
- EXE =
- INCLUDES = -I. -I..
--COMPILE_C = $(COMPILE_PREFIX)gcc -msoft-float -c -o $@ $(INCLUDES) -I- -O2
--LINK = $(COMPILE_PREFIX)gcc -o $@
-+COMPILE_C = $(CC) -msoft-float -c -o $@ $(INCLUDES) -I- -O2
-+LINK = $(CC) -o $@
- 
- ALL: softfloat$(OBJ) timesoftfloat$(EXE)
- 
-diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile
-index a5e2cc7..c34e16e 100644
---- a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile
-+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile
-@@ -5,8 +5,8 @@ SOFTFLOAT_MACROS = ../softfloat-macros
- OBJ = .o
- EXE =
- INCLUDES = -I. -I..
--COMPILE_C = $(COMPILE_PREFIX) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2
--LINK = $(COMPILE_PREFIX) -o $@
-+COMPILE_C = $(CC) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2
-+LINK = $(CC) -o $@
- 
- ALL: softfloat$(OBJ) timesoftfloat$(EXE)
- 
-diff --git a/testfloat/powerpc-linux-gcc/Makefile b/testfloat/powerpc-linux-gcc/Makefile
-index de50aad..1a8b5f7 100644
---- a/testfloat/powerpc-linux-gcc/Makefile
-+++ b/testfloat/powerpc-linux-gcc/Makefile
-@@ -8,13 +8,13 @@ OBJ = .o
- EXE =
- INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR)
- 
--COMPILE_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS)
-+COMPILE_C = $(CC) -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS)
- 
--COMPILE_C_HARD = $(COMPILE_PREFIX)gcc -c -te500v2 -o $@ $(INCLUDES)
-+COMPILE_C_HARD = $(CC) -c -o $@ $(INCLUDES)
- 
--COMPILE_SLOWFLOAT_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O
-+COMPILE_SLOWFLOAT_C = $(CC) -c -o $@ $(INCLUDES) -I- -O
- 
--LINK = $(COMPILE_PREFIX)gcc -lm -o $@
-+LINK = $(CC) -lm -o $@ ${LDFLAGS}
- 
- SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h
- SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ)
--- 
-1.7.3.4
-
diff --git a/recipes-extended/testfloat/testfloat_2a.bb b/recipes-extended/testfloat/testfloat_2a.bb
deleted file mode 100644
index d0bd4d8f1..000000000
--- a/recipes-extended/testfloat/testfloat_2a.bb
+++ /dev/null
@@ -1,48 +0,0 @@
-SUMMARY = "Floating-point implementation test suite"
-DESCRIPTION = "A program for testing floating-point implementation"
-HOMEPAGE = "http://www.jhauser.us/arithmetic/TestFloat.html"
-SECTION = "devel"
-LICENSE = "TestFloat"
-
-LIC_FILES_CHKSUM = "file://testfloat/testfloat.txt;beginline=87;endline=95;md5=bdb2e8111838a48015c29bd97f5b6145"
-
-SRC_URI = "http://www.jhauser.us/arithmetic/TestFloat-2a.tar.Z;name=TestFloat \
-           http://www.jhauser.us/arithmetic/SoftFloat-2b.tar.Z;name=SoftFloat \
-           "
-SRC_URI:append:qoriq-ppc = " \
-    file://SoftFloat-powerpc-1.patch \
-    file://TestFloat-powerpc-E500v2-SPE-1.patch \
-    file://Yocto-replace-COMPILE_PREFIX-gcc.patch \
-"
-SRC_URI[TestFloat.sha256sum] = "84d14aa42adefbda2ec9708b42946f7fa59f93689b042684bd027863481f8e4e"
-SRC_URI[SoftFloat.sha256sum] = "89d14b55113a2ba8cbda7011443ba1d298d381c89d939515d56c5f18f2febf81"
-
-S = "${UNPACKDIR}/TestFloat-2a"
-
-do_unpack2(){
-    mv ${UNPACKDIR}/SoftFloat-2b ${S}/SoftFloat-2b
-    cd ${S}
-    if [ -n "$(which fromdos)" ];then
-        find -type f -exec fromdos {} \;
-    elif [ -n "$(which dos2unix)" ];then
-        find -type f -exec dos2unix {} \;
-    else
-        echo -e "\nERROR: command dos2unix or fromdos not found\n" && return 1
-    fi
-}
-do_unpack2[doc] = "Move the SoftFloat sources into ${S} and convert the shipped DOS line endings"
-addtask do_unpack2 after do_unpack before do_patch
-
-do_compile(){
-    oe_runmake -C testfloat/powerpc-linux-gcc/ CC="${CC}" EXTRA_CFLAGS="-DTEST_KERNEL_EMU"
-}
-
-do_install(){
-    install -d ${D}/${bindir}
-    install testfloat/powerpc-linux-gcc/testfloat ${D}/${bindir}
-    install testfloat/powerpc-linux-gcc/testsoftfloat ${D}/${bindir}
-}
-
-COMPATIBLE_HOST:e500v2 = ".*"
-COMPATIBLE_HOST ?= "(none)"
-