* sysdeps/unix/sysv/linux/sparc/sparc64/dl-procinfo.c: Moved to ...

	* sysdeps/sparc/dl-procinfo.c: ... here, new file.
	* sysdeps/unix/sysv/linux/sparc/sparc64/dl-procinfo.h: Moved to ...
	* sysdeps/sparc/dl-procinfo.h: ... here, new file.
	(HWCAP_IMPORTANT): Include HWCAP_SPARC_V9 when [__WORDSIZE__ != 64].
	* sysdeps/unix/sysv/linux/sparc/sparc32/dl-procinfo.c: File removed.
	* sysdeps/unix/sysv/linux/sparc/sparc32/dl-procinfo.h: File removed.

2006-02-18  Joseph S. Myers  <joseph@codesourcery.com>

	* soft-fp/single.h (SFtype): Define.
	(union _FP_UNION_S): Use it.
	* soft-fp/double.h (DFtype): Define.
	(union _FP_UNION_D): Use it.
	* soft-fp/extended.h (XFtype): Define.
	(union _FP_UNION_E): Use it.
	* soft-fp/quad.h (TFtype): Define.
	(union _FP_UNION_Q): Use it.
	* soft-fp/soft-fp.h: Add _LIBC conditionals.
	(SI_BITS, DI_BITS): Define.
	* soft-fp/op-common.h (_FP_DECL): Add __attribute__((unused)) for
	X##_c.
	(_FP_CMP_EQ): Use parentheses for && inside ||.
	(_FP_TO_INT): Use statement expressions in conditional controlling
	constant shift.
	(_FP_FROM_INT): Likewise.  Take unsigned type as argument.
	* soft-fp/op-2.h (_FP_FRAC_SLL_2, _FP_FRAC_SRL_2, _FP_FRAC_SRST_2,
	_FP_FRAC_SRS_2, _FP_FRAC_ASSEMBLE_2): Use statement expressions in
	conditional controlling possibly constant shift.
	(_FP_FRAC_SRST_2, _FP_FRAC_SRS_2): Avoid left shift by exactly
	_FP_W_TYPE_SIZE.
	(_FP_FRAC_GT_2, _FP_FRAC_GE_2): Use parentheses for && inside ||.
	* soft-fp/op-4.h (_FP_FRAC_SRST_4): Avoid left shift by exactly
	_FP_W_TYPE_SIZE.
	(__FP_FRAC_ADD_3, __FP_FRAC_ADD_4, __FP_FRAC_SUB_3,
	__FP_FRAC_SUB_4): Use _FP_W_TYPE for carry flags.
	* soft-fp/op-8.h (_FP_FRAC_SRS_8): Avoid left shift by exactly
	_FP_W_TYPE_SIZE.
	* soft-fp/floatdidf.c: Pass unsigned type and macro for type size.
	* soft-fp/floatdisf.c: Likewise.
	* soft-fp/floatditf.c: Likewise.
	* soft-fp/floatsidf.c: Likewise.
	* soft-fp/floatsisf.c: Likewise.
	* soft-fp/floatsitf.c: Likewise.
	* soft-fp/floatundidf.c: Likewise.
	* soft-fp/floatundisf.c: Likewise.
	* soft-fp/floatunditf.c: Likewise.
	* soft-fp/floatunsidf.c: Likewise.
	* soft-fp/floatunsisf.c: Likewise.
	* soft-fp/floatunsitf.c: Likewise.
	* soft-fp/fixdfdi.c: Pass macro for type size.
	* soft-fp/fixdfsi.c: Likewise.
	* soft-fp/fixsfdi.c: Likewise.
	* soft-fp/fixsfsi.c: Likewise.
	* soft-fp/fixtfdi.c: Likewise.
	* soft-fp/fixtfsi.c: Likewise.
	* soft-fp/fixunsdfdi.c: Likewise.
	* soft-fp/fixunsdfsi.c: Likewise.
	* soft-fp/fixunssfdi.c: Likewise.
	* soft-fp/fixunssfsi.c: Likewise.
	* soft-fp/fixunstfdi.c: Likewise.
	* soft-fp/fixunstfsi.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvtqux.c: Pass unsigned type.
	* sysdeps/alpha/soft-fp/ots_cvtqx.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_itoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_lltoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_ulltoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_utoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_itoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_lltoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_ulltoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_utoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_itoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_uitoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_uxtoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_xtoq.c: Likewise.
	* soft-fp/adddf3.c: Use typedefs for argument and return types.
        * soft-fp/addsf3.c: Likewise.
        * soft-fp/addtf3.c: Likewise.
        * soft-fp/divdf3.c: Likewise.
        * soft-fp/divsf3.c: Likewise.
        * soft-fp/divtf3.c: Likewise.
        * soft-fp/eqdf2.c: Likewise.
        * soft-fp/eqsf2.c: Likewise.
        * soft-fp/eqtf2.c: Likewise.
        * soft-fp/extenddftf2.c: Likewise.
        * soft-fp/extendsfdf2.c: Likewise.
        * soft-fp/extendsftf2.c: Likewise.
        * soft-fp/fixdfdi.c: Likewise.
        * soft-fp/fixdfsi.c: Likewise.
        * soft-fp/fixsfdi.c: Likewise.
        * soft-fp/fixsfsi.c: Likewise.
        * soft-fp/fixtfdi.c: Likewise.
        * soft-fp/fixtfsi.c: Likewise.
        * soft-fp/fixunsdfdi.c: Likewise.
        * soft-fp/fixunsdfsi.c: Likewise.
        * soft-fp/fixunssfdi.c: Likewise.
        * soft-fp/fixunssfsi.c: Likewise.
        * soft-fp/fixunstfdi.c: Likewise.
        * soft-fp/fixunstfsi.c: Likewise.
        * soft-fp/floatdidf.c: Likewise.
        * soft-fp/floatdisf.c: Likewise.
        * soft-fp/floatditf.c: Likewise.
        * soft-fp/floatsidf.c: Likewise.
        * soft-fp/floatsisf.c: Likewise.
        * soft-fp/floatsitf.c: Likewise.
        * soft-fp/floatundidf.c: Likewise.
        * soft-fp/floatundisf.c: Likewise.
        * soft-fp/floatunditf.c: Likewise.
        * soft-fp/floatunsidf.c: Likewise.
        * soft-fp/floatunsisf.c: Likewise.
        * soft-fp/floatunsitf.c: Likewise.
        * soft-fp/gedf2.c: Likewise.
        * soft-fp/gesf2.c: Likewise.
        * soft-fp/getf2.c: Likewise.
        * soft-fp/ledf2.c: Likewise.
        * soft-fp/lesf2.c: Likewise.
        * soft-fp/letf2.c: Likewise.
        * soft-fp/muldf3.c: Likewise.
        * soft-fp/mulsf3.c: Likewise.
        * soft-fp/multf3.c: Likewise.
        * soft-fp/negdf2.c: Likewise.
        * soft-fp/negsf2.c: Likewise.
        * soft-fp/negtf2.c: Likewise.
        * soft-fp/sqrtdf2.c: Likewise.
        * soft-fp/sqrtsf2.c: Likewise.
        * soft-fp/sqrttf2.c: Likewise.
        * soft-fp/subdf3.c: Likewise.
        * soft-fp/subsf3.c: Likewise.
        * soft-fp/subtf3.c: Likewise.
        * soft-fp/truncdfsf2.c: Likewise.
        * soft-fp/trunctfdf2.c: Likewise.
        * soft-fp/trunctfsf2.c: Likewise.
        * soft-fp/unorddf2.c: Likewise.
        * soft-fp/unordsf2.c: Likewise.
        * soft-fp/unordtf2.c: Likewise.

2006-02-09  Joseph S. Myers  <joseph@codesourcery.com>

	* soft-fp/op-common.h (_FP_UNPACK_SEMIRAW): Define.
	(_FP_OVERFLOW_SEMIRAW): Likewise.
	(_FP_CHECK_SIGNAN_SEMIRAW): Likewise.
	(_FP_CHOOSENAN_SEMIRAW): Likewise.
	(_FP_EXP_NORMAL): Likewise.
	(_FP_PACK_SEMIRAW): Likewise.
	(_FP_ADD_INTERNAL): Rewrite to operate on semi-raw value.
	(_FP_SUB): Likewise.
	(_FP_TO_INT): Rewrite to operate on raw values.  Don't set INVALID
	exception for conversions where most negative representable
	integer is correct truncated value, but do set INEXACT for such
	conversions where appropriate.  Don't always left-shift for
	converting to a wider integer.
	(_FP_FROM_INT): Rewrite to yield raw value.  Correct shift for
	integers with one more bits than (mantissa + guard) bits for the
	floating point format.  Don't use __FP_FRAC_SRS_1 for shifting
	integers that may be wider than _FP_W_TYPE_SIZE.
	(FP_CONV): Don't define.
	(FP_EXTEND): Define.
	(FP_TRUNC): Likewise.
	* soft-fp/op-1.h (_FP_FRAC_SRST_1, __FP_FRAC_SRST_1): Define.
	(_FP_FRAC_CONV_1_1): Don't define.
	(_FP_FRAC_COPY_1_1): Define.
	* soft-fp/op-2.h (_FP_FRAC_SRST_2): Define.
	(_FP_FRAC_CONV_1_2, _FP_FRAC_CONV_2_1): Don't define.
	(_FP_FRAC_COPY_1_2, _FP_FRAC_COPY_2_1): Define.
	* soft-fp/op-4.h (_FP_FRAC_SRST_4): Define.
	(_FP_FRAC_SRS_4): Define based on _FP_FRAC_SRST_4.
	(_FP_FRAC_CONV_1_4, _FP_FRAC_CONV_2_4): Don't define.
	(_FP_FRAC_COPY_1_4, _FP_FRAC_COPY_2_4): Define.
	(_FP_FRAC_CONV_4_1, _FP_FRAC_CONV_4_2): Don't define.
	(_FP_FRAC_COPY_4_1, _FP_FRAC_COPY_4_2): Define.
	* soft-fp/single.h (_FP_FRACTBITS_S): Define.
	(_FP_FRACXBITS_S): Define in terms of _FP_FRACXBITS_S.
	(_FP_WFRACXBITS_S): Likewise.
	(_FP_QNANBIT_SH_S, _FP_IMPLBIT_SH_S): Define.
	(FP_UNPACK_SEMIRAW_S, FP_UNPACK_SEMIRAW_SP): Define.
	(FP_PACK_SEMIRAW_S, FP_PACK_SEMIRAW_SP): Define.
	* soft-fp/double.h (_FP_QNANBIT_SH_D, _FP_IMPLBIT_SH_D): Define.
	(FP_UNPACK_SEMIRAW_D, FP_UNPACK_SEMIRAW_D): Define
	(FP_PACK_SEMIRAW_D, FP_PACK_SEMIRAW_DP): Define.
	* soft-fp/extended.h (_FP_QNANBIT_SH_E, _FP_IMPLBIT_SH_E): Define.
	(FP_UNPACK_EP): Correct typo.
	(FP_UNPACK_SEMIRAW_E, FP_UNPACK_SEMIRAW_EP): Define.
	(FP_PACK_SEMIRAW_E, FP_PACK_SEMIRAW_EP): Define.
	* soft-fp/quad.h (_FP_QNANBIT_SH_Q, _FP_IMPLBIT_SH_Q): Define.
	(FP_UNPACK_SEMIRAW_Q, FP_UNPACK_SEMIRAW_QP): Define.
	(FP_PACK_SEMIRAW_Q, FP_PACK_SEMIRAW_QP): Define.
	* soft-fp/fixdfdi.c: Use unsigned type for result of conversion.
	* soft-fp/fixdfsi.c: Likewise.
	* soft-fp/fixsfdi.c: Likewise.
	* soft-fp/fixsfsi.c: Likewise.
	* soft-fp/fixtfdi.c: Likewise.
	* soft-fp/fixtfsi.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvtxq.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_nintxq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtoi.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtoll.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtoi.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtoll.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtoi.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtox.c: Likewise.
	* soft-fp/adddf3.c: Update for changed soft-fp interfaces.
	* soft-fp/addsf3.c: Likewise.
	* soft-fp/addtf3.c: Likewise.
	* soft-fp/extenddftf2.c: Likewise.
	* soft-fp/extendsfdf2.c: Likewise.
	* soft-fp/extendsftf2.c: Likewise.
	* soft-fp/fixdfdi.c: Likewise.
	* soft-fp/fixdfsi.c: Likewise.
	* soft-fp/fixsfdi.c: Likewise.
	* soft-fp/fixsfsi.c: Likewise.
	* soft-fp/fixtfdi.c: Likewise.
	* soft-fp/fixtfsi.c: Likewise.
	* soft-fp/fixunsdfdi.c: Likewise.
	* soft-fp/fixunsdfsi.c: Likewise.
	* soft-fp/fixunssfdi.c: Likewise.
	* soft-fp/fixunssfsi.c: Likewise.
	* soft-fp/fixunstfdi.c: Likewise.
	* soft-fp/fixunstfsi.c: Likewise.
	* soft-fp/floatdidf.c: Likewise.
	* soft-fp/floatdisf.c: Likewise.
	* soft-fp/floatditf.c: Likewise.
	* soft-fp/floatsidf.c: Likewise.
	* soft-fp/floatsisf.c: Likewise.
	* soft-fp/floatsitf.c: Likewise.
	* soft-fp/floatundidf.c: Likewise.
	* soft-fp/floatundisf.c: Likewise.
	* soft-fp/floatunditf.c: Likewise.
	* soft-fp/floatunsidf.c: Likewise.
	* soft-fp/floatunsisf.c: Likewise.
	* soft-fp/floatunsitf.c: Likewise.
	* soft-fp/subdf3.c: Likewise.
	* soft-fp/subsf3.c: Likewise.
	* soft-fp/subtf3.c: Likewise.
	* soft-fp/truncdfsf2.c: Likewise.
	* soft-fp/trunctfdf2.c: Likewise.
	* soft-fp/trunctfsf2.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_add.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvtqux.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvtqx.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvttx.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvtxq.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_cvtxt.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_nintxq.c: Likewise.
	* sysdeps/alpha/soft-fp/ots_sub.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_add.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_dtoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_itoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_lltoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtod.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtoi.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtoll.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtos.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtou.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_qtoull.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_stoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_sub.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_ulltoq.c: Likewise.
	* sysdeps/powerpc/soft-fp/q_utoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_add.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_dtoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_itoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_lltoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtod.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtoi.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtoll.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtos.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtou.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_qtoull.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_stoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_sub.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_ulltoq.c: Likewise.
	* sysdeps/sparc/sparc32/soft-fp/q_utoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_add.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_dtoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_itoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtod.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtoi.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtos.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtoui.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtoux.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_qtox.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_stoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_sub.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_uitoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_uxtoq.c: Likewise.
	* sysdeps/sparc/sparc64/soft-fp/qp_xtoq.c: Likewise.

70 files changed, 1393 insertions, 675 deletions

diff --git a/soft-fp/adddf3.c b/soft-fp/adddf3.c
index 6802d13..269ef66 100644
--- a/soft-fp/adddf3.c
+++ b/soft-fp/adddf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a + b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999, 2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,17 +23,17 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __adddf3(double a, double b)
+DFtype __adddf3(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
-  FP_UNPACK_D(B, b);
+  FP_UNPACK_SEMIRAW_D(A, a);
+  FP_UNPACK_SEMIRAW_D(B, b);
   FP_ADD_D(R, A, B);
-  FP_PACK_D(r, R);
+  FP_PACK_SEMIRAW_D(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/addsf3.c b/soft-fp/addsf3.c
index a1e7f0c..cfd9526 100644
--- a/soft-fp/addsf3.c
+++ b/soft-fp/addsf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a + b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,17 +23,17 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __addsf3(float a, float b)
+SFtype __addsf3(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
-  FP_UNPACK_S(B, b);
+  FP_UNPACK_SEMIRAW_S(A, a);
+  FP_UNPACK_SEMIRAW_S(B, b);
   FP_ADD_S(R, A, B);
-  FP_PACK_S(r, R);
+  FP_PACK_SEMIRAW_S(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/addtf3.c b/soft-fp/addtf3.c
index b7348f5..f889a18 100644
--- a/soft-fp/addtf3.c
+++ b/soft-fp/addtf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a + b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,17 +23,17 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __addtf3(long double a, long double b)
+TFtype __addtf3(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
-  FP_UNPACK_Q(B, b);
+  FP_UNPACK_SEMIRAW_Q(A, a);
+  FP_UNPACK_SEMIRAW_Q(B, b);
   FP_ADD_Q(R, A, B);
-  FP_PACK_Q(r, R);
+  FP_PACK_SEMIRAW_Q(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/divdf3.c b/soft-fp/divdf3.c
index f8a479d..b45a91c 100644
--- a/soft-fp/divdf3.c
+++ b/soft-fp/divdf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a / b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __divdf3(double a, double b)
+DFtype __divdf3(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_D(A, a);
diff --git a/soft-fp/divsf3.c b/soft-fp/divsf3.c
index 9e9234f..d62c7c0 100644
--- a/soft-fp/divsf3.c
+++ b/soft-fp/divsf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a / b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __divsf3(float a, float b)
+SFtype __divsf3(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_S(A, a);
diff --git a/soft-fp/divtf3.c b/soft-fp/divtf3.c
index 264af97..842aa81 100644
--- a/soft-fp/divtf3.c
+++ b/soft-fp/divtf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a / b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __divtf3(long double a, long double b)
+TFtype __divtf3(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_Q(A, a);
diff --git a/soft-fp/double.h b/soft-fp/double.h
index 4d66c8d..86fd8ad 100644
--- a/soft-fp/double.h
+++ b/soft-fp/double.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Definitions for IEEE Double Precision
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz),
@@ -42,16 +42,22 @@
 
 #define _FP_QNANBIT_D		\
 	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-2) % _FP_W_TYPE_SIZE)
+#define _FP_QNANBIT_SH_D		\
+	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_D		\
 	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-1) % _FP_W_TYPE_SIZE)
+#define _FP_IMPLBIT_SH_D		\
+	((_FP_W_TYPE)1 << (_FP_FRACBITS_D-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_OVERFLOW_D		\
 	((_FP_W_TYPE)1 << _FP_WFRACBITS_D % _FP_W_TYPE_SIZE)
 
+typedef float DFtype __attribute__((mode(DF)));
+
 #if _FP_W_TYPE_SIZE < 64
 
 union _FP_UNION_D
 {
-  double flt;
+  DFtype flt;
   struct {
 #if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign  : 1;
@@ -89,6 +95,18 @@ union _FP_UNION_D
     _FP_UNPACK_CANONICAL(D,2,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_D(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_2(D,X,val);		\
+    _FP_UNPACK_SEMIRAW(D,2,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_DP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_2_P(D,X,val);	\
+    _FP_UNPACK_SEMIRAW(D,2,X);		\
+  } while (0)
+
 #define FP_PACK_D(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(D,2,X);		\
@@ -102,6 +120,19 @@ union _FP_UNION_D
       _FP_PACK_RAW_2_P(D,val,X);	\
   } while (0)
 
+#define FP_PACK_SEMIRAW_D(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(D,2,X);		\
+    _FP_PACK_RAW_2(D,val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_DP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(D,2,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_2_P(D,val,X);	\
+  } while (0)
+
 #define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,2,X)
 #define FP_NEG_D(R,X)			_FP_NEG(D,2,R,X)
 #define FP_ADD_D(R,X,Y)			_FP_ADD(D,2,R,X,Y)
@@ -125,7 +156,7 @@ union _FP_UNION_D
 
 union _FP_UNION_D
 {
-  double flt;
+  DFtype flt;
   struct {
 #if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign : 1;
@@ -161,6 +192,18 @@ union _FP_UNION_D
     _FP_UNPACK_CANONICAL(D,1,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_D(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_2(1,X,val);		\
+    _FP_UNPACK_SEMIRAW(D,1,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_DP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_2_P(1,X,val);	\
+    _FP_UNPACK_SEMIRAW(D,1,X);		\
+  } while (0)
+
 #define FP_PACK_D(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(D,1,X);		\
@@ -174,6 +217,19 @@ union _FP_UNION_D
       _FP_PACK_RAW_1_P(D,val,X);	\
   } while (0)
 
+#define FP_PACK_SEMIRAW_D(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(D,1,X);		\
+    _FP_PACK_RAW_1(D,val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_DP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(D,1,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_1_P(D,val,X);	\
+  } while (0)
+
 #define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,1,X)
 #define FP_NEG_D(R,X)			_FP_NEG(D,1,R,X)
 #define FP_ADD_D(R,X,Y)			_FP_ADD(D,1,R,X,Y)
diff --git a/soft-fp/eqdf2.c b/soft-fp/eqdf2.c
index b2586bd..d1eb972 100644
--- a/soft-fp/eqdf2.c
+++ b/soft-fp/eqdf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 otherwise
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "double.h"
 
-int __eqdf2(double a, double b)
+int __eqdf2(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B);
diff --git a/soft-fp/eqsf2.c b/soft-fp/eqsf2.c
index d838b52..371465f 100644
--- a/soft-fp/eqsf2.c
+++ b/soft-fp/eqsf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 otherwise
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "single.h"
 
-int __eqsf2(float a, float b)
+int __eqsf2(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B);
diff --git a/soft-fp/eqtf2.c b/soft-fp/eqtf2.c
index adb1663..59479b4 100644
--- a/soft-fp/eqtf2.c
+++ b/soft-fp/eqtf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 otherwise
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-int __eqtf2(long double a, long double b)
+int __eqtf2(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B);
diff --git a/soft-fp/extenddftf2.c b/soft-fp/extenddftf2.c
index 53ac72c..e25cc5c 100644
--- a/soft-fp/extenddftf2.c
+++ b/soft-fp/extenddftf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a converted to IEEE quad
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -24,21 +24,21 @@
 #include "double.h"
 #include "quad.h"
 
-long double __extenddftf2(double a)
+TFtype __extenddftf2(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
   FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
+  FP_UNPACK_RAW_D(A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_CONV(Q,D,4,2,R,A);
+  FP_EXTEND(Q,D,4,2,R,A);
 #else
-  FP_CONV(Q,D,2,1,R,A);
+  FP_EXTEND(Q,D,2,1,R,A);
 #endif
-  FP_PACK_Q(r, R);
+  FP_PACK_RAW_Q(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/extended.h b/soft-fp/extended.h
index d34df5d..0f2060e 100644
--- a/soft-fp/extended.h
+++ b/soft-fp/extended.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Definitions for IEEE Extended Precision.
-   Copyright (C) 1999 Free Software Foundation, Inc.
+   Copyright (C) 1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Jakub Jelinek (jj@ultra.linux.cz).
 
@@ -39,16 +39,22 @@
 
 #define _FP_QNANBIT_E		\
 	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
+#define _FP_QNANBIT_SH_E		\
+	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_E		\
 	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
+#define _FP_IMPLBIT_SH_E		\
+	((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_OVERFLOW_E		\
 	((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
 
+typedef float XFtype __attribute__((mode(XF)));
+
 #if _FP_W_TYPE_SIZE < 64
 
 union _FP_UNION_E
 {
-   long double flt;
+   XFtype flt;
    struct 
    {
 #if __BYTE_ORDER == __BIG_ENDIAN
@@ -143,10 +149,22 @@ union _FP_UNION_E
 
 #define FP_UNPACK_EP(X,val)		\
   do {					\
-    FP_UNPACK_RAW_2_P(X,val);		\
+    FP_UNPACK_RAW_EP(X,val);		\
     _FP_UNPACK_CANONICAL(E,4,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_E(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_E(X,val);		\
+    _FP_UNPACK_SEMIRAW(E,4,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_EP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_EP(X,val);		\
+    _FP_UNPACK_SEMIRAW(E,4,X);		\
+  } while (0)
+
 #define FP_PACK_E(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(E,4,X);		\
@@ -159,6 +177,18 @@ union _FP_UNION_E
     FP_PACK_RAW_EP(val,X);		\
   } while (0)
 
+#define FP_PACK_SEMIRAW_E(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(E,4,X);		\
+    _FP_PACK_RAW_E(val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_EP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(E,4,X);		\
+    _FP_PACK_RAW_EP(val,X);		\
+  } while (0)
+
 #define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,4,X)
 #define FP_NEG_E(R,X)		_FP_NEG(E,4,R,X)
 #define FP_ADD_E(R,X,Y)		_FP_ADD(E,4,R,X,Y)
@@ -235,7 +265,7 @@ union _FP_UNION_E
 #else   /* not _FP_W_TYPE_SIZE < 64 */
 union _FP_UNION_E
 {
-  long double flt /* __attribute__((mode(TF))) */ ;
+  XFtype flt;
   struct {
 #if __BYTE_ORDER == __BIG_ENDIAN
     unsigned long pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
@@ -324,6 +354,18 @@ union _FP_UNION_E
     _FP_UNPACK_CANONICAL(E,2,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_E(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_E(X,val);		\
+    _FP_UNPACK_SEMIRAW(E,2,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_EP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_EP(X,val);		\
+    _FP_UNPACK_SEMIRAW(E,2,X);		\
+  } while (0)
+
 #define FP_PACK_E(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(E,2,X);		\
@@ -336,6 +378,18 @@ union _FP_UNION_E
     FP_PACK_RAW_EP(val,X);		\
   } while (0)
 
+#define FP_PACK_SEMIRAW_E(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(E,2,X);		\
+    _FP_PACK_RAW_E(val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_EP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(E,2,X);		\
+    _FP_PACK_RAW_EP(val,X);		\
+  } while (0)
+
 #define FP_ISSIGNAN_E(X)	_FP_ISSIGNAN(E,2,X)
 #define FP_NEG_E(R,X)		_FP_NEG(E,2,R,X)
 #define FP_ADD_E(R,X,Y)		_FP_ADD(E,2,R,X,Y)
diff --git a/soft-fp/extendsfdf2.c b/soft-fp/extendsfdf2.c
index a418f19..220caf9 100644
--- a/soft-fp/extendsfdf2.c
+++ b/soft-fp/extendsfdf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a converted to IEEE double
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -24,21 +24,21 @@
 #include "single.h"
 #include "double.h"
 
-double __extendsfdf2(float a)
+DFtype __extendsfdf2(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
   FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
+  FP_UNPACK_RAW_S(A, a);
 #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D
-  FP_CONV(D,S,2,1,R,A);
+  FP_EXTEND(D,S,2,1,R,A);
 #else
-  FP_CONV(D,S,1,1,R,A);
+  FP_EXTEND(D,S,1,1,R,A);
 #endif
-  FP_PACK_D(r, R);
+  FP_PACK_RAW_D(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/extendsftf2.c b/soft-fp/extendsftf2.c
index d2735ba..412d2e8 100644
--- a/soft-fp/extendsftf2.c
+++ b/soft-fp/extendsftf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a converted to IEEE quad
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -24,21 +24,21 @@
 #include "single.h"
 #include "quad.h"
 
-long double __extendsftf2(float a)
+TFtype __extendsftf2(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
   FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
+  FP_UNPACK_RAW_S(A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_CONV(Q,S,4,1,R,A);
+  FP_EXTEND(Q,S,4,1,R,A);
 #else
-  FP_CONV(Q,S,2,1,R,A);
+  FP_EXTEND(Q,S,2,1,R,A);
 #endif
-  FP_PACK_Q(r, R);
+  FP_PACK_RAW_Q(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixdfdi.c b/soft-fp/fixdfdi.c
index 2010145..537de10 100644
--- a/soft-fp/fixdfdi.c
+++ b/soft-fp/fixdfdi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 64bit signed integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "double.h"
 
-DItype __fixdfdi(double a)
+DItype __fixdfdi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
-  DItype r;
+  UDItype r;
 
-  FP_UNPACK_D(A, a);
-  FP_TO_INT_D(r, A, 64, 1);
+  FP_UNPACK_RAW_D(A, a);
+  FP_TO_INT_D(r, A, DI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixdfsi.c b/soft-fp/fixdfsi.c
index 9961d3d..0607005 100644
--- a/soft-fp/fixdfsi.c
+++ b/soft-fp/fixdfsi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 32bit signed integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "double.h"
 
-SItype __fixdfsi(double a)
+SItype __fixdfsi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
-  SItype r;
+  USItype r;
 
-  FP_UNPACK_D(A, a);
-  FP_TO_INT_D(r, A, 32, 1);
+  FP_UNPACK_RAW_D(A, a);
+  FP_TO_INT_D(r, A, SI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixsfdi.c b/soft-fp/fixsfdi.c
index f3fd2e7..d9ef9e8 100644
--- a/soft-fp/fixsfdi.c
+++ b/soft-fp/fixsfdi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 64bit signed integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "single.h"
 
-DItype __fixsfdi(float a)
+DItype __fixsfdi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
-  DItype r;
+  UDItype r;
 
-  FP_UNPACK_S(A, a);
-  FP_TO_INT_S(r, A, 64, 1);
+  FP_UNPACK_RAW_S(A, a);
+  FP_TO_INT_S(r, A, DI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixsfsi.c b/soft-fp/fixsfsi.c
index e8251d1..916b079 100644
--- a/soft-fp/fixsfsi.c
+++ b/soft-fp/fixsfsi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 32bit signed integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "single.h"
 
-SItype __fixsfsi(float a)
+SItype __fixsfsi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
-  SItype r;
+  USItype r;
 
-  FP_UNPACK_S(A, a);
-  FP_TO_INT_S(r, A, 32, 1);
+  FP_UNPACK_RAW_S(A, a);
+  FP_TO_INT_S(r, A, SI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixtfdi.c b/soft-fp/fixtfdi.c
index fda4122..73a1cc7 100644
--- a/soft-fp/fixtfdi.c
+++ b/soft-fp/fixtfdi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 64bit signed integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-DItype __fixtfdi(long double a)
+DItype __fixtfdi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
-  DItype r;
+  UDItype r;
 
-  FP_UNPACK_Q(A, a);
-  FP_TO_INT_Q(r, A, 64, 1);
+  FP_UNPACK_RAW_Q(A, a);
+  FP_TO_INT_Q(r, A, DI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixtfsi.c b/soft-fp/fixtfsi.c
index da51cf9..78bad0e 100644
--- a/soft-fp/fixtfsi.c
+++ b/soft-fp/fixtfsi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 32bit signed integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-SItype __fixtfsi(long double a)
+SItype __fixtfsi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
-  SItype r;
+  USItype r;
 
-  FP_UNPACK_Q(A, a);
-  FP_TO_INT_Q(r, A, 32, 1);
+  FP_UNPACK_RAW_Q(A, a);
+  FP_TO_INT_Q(r, A, SI_BITS, 1);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixunsdfdi.c b/soft-fp/fixunsdfdi.c
index 18bc61c..b350d95 100644
--- a/soft-fp/fixunsdfdi.c
+++ b/soft-fp/fixunsdfdi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 64bit unsigned integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "double.h"
 
-UDItype __fixunsdfdi(double a)
+UDItype __fixunsdfdi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
   UDItype r;
 
-  FP_UNPACK_D(A, a);
-  FP_TO_INT_D(r, A, 64, 0);
+  FP_UNPACK_RAW_D(A, a);
+  FP_TO_INT_D(r, A, DI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixunsdfsi.c b/soft-fp/fixunsdfsi.c
index 4060b51..c363e5f 100644
--- a/soft-fp/fixunsdfsi.c
+++ b/soft-fp/fixunsdfsi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 32bit unsigned integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "double.h"
 
-USItype __fixunsdfsi(double a)
+USItype __fixunsdfsi(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
   USItype r;
 
-  FP_UNPACK_D(A, a);
-  FP_TO_INT_D(r, A, 32, 0);
+  FP_UNPACK_RAW_D(A, a);
+  FP_TO_INT_D(r, A, SI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixunssfdi.c b/soft-fp/fixunssfdi.c
index 6e4f5be..6a43cb8 100644
--- a/soft-fp/fixunssfdi.c
+++ b/soft-fp/fixunssfdi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 64bit unsigned integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "single.h"
 
-UDItype __fixunssfdi(float a)
+UDItype __fixunssfdi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
   UDItype r;
 
-  FP_UNPACK_S(A, a);
-  FP_TO_INT_S(r, A, 64, 0);
+  FP_UNPACK_RAW_S(A, a);
+  FP_TO_INT_S(r, A, DI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixunssfsi.c b/soft-fp/fixunssfsi.c
index 5c3e993..3ddcee5 100644
--- a/soft-fp/fixunssfsi.c
+++ b/soft-fp/fixunssfsi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 32bit unsigned integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "single.h"
 
-USItype __fixunssfsi(float a)
+USItype __fixunssfsi(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
   USItype r;
 
-  FP_UNPACK_S(A, a);
-  FP_TO_INT_S(r, A, 32, 0);
+  FP_UNPACK_RAW_S(A, a);
+  FP_TO_INT_S(r, A, SI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixunstfdi.c b/soft-fp/fixunstfdi.c
index a8ac454..0bf5327 100644
--- a/soft-fp/fixunstfdi.c
+++ b/soft-fp/fixunstfdi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 64bit unsigned integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-UDItype __fixunstfdi(long double a)
+UDItype __fixunstfdi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
   UDItype r;
 
-  FP_UNPACK_Q(A, a);
-  FP_TO_INT_Q(r, A, 64, 0);
+  FP_UNPACK_RAW_Q(A, a);
+  FP_TO_INT_Q(r, A, DI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/fixunstfsi.c b/soft-fp/fixunstfsi.c
index 812fb8e..387b9c6 100644
--- a/soft-fp/fixunstfsi.c
+++ b/soft-fp/fixunstfsi.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a to 32bit unsigned integer
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-USItype __fixunstfsi(long double a)
+USItype __fixunstfsi(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
   USItype r;
 
-  FP_UNPACK_Q(A, a);
-  FP_TO_INT_Q(r, A, 32, 0);
+  FP_UNPACK_RAW_Q(A, a);
+  FP_TO_INT_Q(r, A, SI_BITS, 0);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/floatdidf.c b/soft-fp/floatdidf.c
index 38303f2..2c68000 100644
--- a/soft-fp/floatdidf.c
+++ b/soft-fp/floatdidf.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a 64bit signed integer to IEEE double
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __floatdidf(DItype i)
+DFtype __floatdidf(DItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
-  double a;
+  DFtype a;
 
-  FP_FROM_INT_D(A, i, 64, long long);
-  FP_PACK_D(a, A);
+  FP_FROM_INT_D(A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_D(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatdisf.c b/soft-fp/floatdisf.c
index d2a2af0..36f05ee 100644
--- a/soft-fp/floatdisf.c
+++ b/soft-fp/floatdisf.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a 64bit signed integer to IEEE single
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __floatdisf(DItype i)
+SFtype __floatdisf(DItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
-  float a;
+  SFtype a;
 
-  FP_FROM_INT_S(A, i, 64, long long);
-  FP_PACK_S(a, A);
+  FP_FROM_INT_S(A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_S(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatditf.c b/soft-fp/floatditf.c
index ef05dee..03487ad 100644
--- a/soft-fp/floatditf.c
+++ b/soft-fp/floatditf.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a 64bit signed integer to IEEE quad
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __floatditf(DItype i)
+TFtype __floatditf(DItype i)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
-  long double a;
+  TFtype a;
 
-  FP_FROM_INT_Q(A, i, 64, long long);
-  FP_PACK_Q(a, A);
+  FP_FROM_INT_Q(A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_Q(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatsidf.c b/soft-fp/floatsidf.c
index e136333..d11ddcc 100644
--- a/soft-fp/floatsidf.c
+++ b/soft-fp/floatsidf.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a 32bit signed integer to IEEE double
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __floatsidf(SItype i)
+DFtype __floatsidf(SItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
-  double a;
+  DFtype a;
 
-  FP_FROM_INT_D(A, i, 32, int);
-  FP_PACK_D(a, A);
+  FP_FROM_INT_D(A, i, SI_BITS, USItype);
+  FP_PACK_RAW_D(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatsisf.c b/soft-fp/floatsisf.c
index d68f5a8..64006e6 100644
--- a/soft-fp/floatsisf.c
+++ b/soft-fp/floatsisf.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a 32bit signed integer to IEEE single
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __floatsisf(SItype i)
+SFtype __floatsisf(SItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
-  float a;
+  SFtype a;
 
-  FP_FROM_INT_S(A, i, 32, int);
-  FP_PACK_S(a, A);
+  FP_FROM_INT_S(A, i, SI_BITS, USItype);
+  FP_PACK_RAW_S(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatsitf.c b/soft-fp/floatsitf.c
index e982bb7..5a64c70 100644
--- a/soft-fp/floatsitf.c
+++ b/soft-fp/floatsitf.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Convert a 32bit signed integer to IEEE quad
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,14 +23,14 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __floatsitf(SItype i)
+TFtype __floatsitf(SItype i)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
-  long double a;
+  TFtype a;
 
-  FP_FROM_INT_Q(A, i, 32, int);
-  FP_PACK_Q(a, A);
+  FP_FROM_INT_Q(A, i, SI_BITS, USItype);
+  FP_PACK_RAW_Q(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatundidf.c b/soft-fp/floatundidf.c
index 03bda04..dcec2f8 100644
--- a/soft-fp/floatundidf.c
+++ b/soft-fp/floatundidf.c
@@ -28,10 +28,10 @@ __floatundidf(UDItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
-  double a;
+  DFtype a;
 
-  FP_FROM_INT_D(A, i, 64, long long);
-  FP_PACK_D(a, A);
+  FP_FROM_INT_D(A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_D(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatundisf.c b/soft-fp/floatundisf.c
index 68aa90f..a2437e4 100644
--- a/soft-fp/floatundisf.c
+++ b/soft-fp/floatundisf.c
@@ -28,10 +28,10 @@ __floatundisf(UDItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
-  float a;
+  SFtype a;
 
-  FP_FROM_INT_S(A, i, 64, long long);
-  FP_PACK_S(a, A);
+  FP_FROM_INT_S(A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_S(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatunditf.c b/soft-fp/floatunditf.c
index 2f53f7d..f0fd3af 100644
--- a/soft-fp/floatunditf.c
+++ b/soft-fp/floatunditf.c
@@ -23,15 +23,15 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double
+TFtype
 __floatunditf(UDItype i)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
-  long double a;
+  TFtype a;
 
-  FP_FROM_INT_Q(A, i, 64, long long);
-  FP_PACK_Q(a, A);
+  FP_FROM_INT_Q(A, i, DI_BITS, UDItype);
+  FP_PACK_RAW_Q(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatunsidf.c b/soft-fp/floatunsidf.c
index 2649adc..b43ed35 100644
--- a/soft-fp/floatunsidf.c
+++ b/soft-fp/floatunsidf.c
@@ -28,10 +28,10 @@ __floatunsidf(USItype i)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
-  double a;
+  DFtype a;
 
-  FP_FROM_INT_D(A, i, 32, int);
-  FP_PACK_D(a, A);
+  FP_FROM_INT_D(A, i, SI_BITS, USItype);
+  FP_PACK_RAW_D(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatunsisf.c b/soft-fp/floatunsisf.c
index a7f21ca..16fbf1d 100644
--- a/soft-fp/floatunsisf.c
+++ b/soft-fp/floatunsisf.c
@@ -28,10 +28,10 @@ __floatunsisf(USItype i)
 {
   FP_DECL_EX;
   FP_DECL_S(A);
-  float a;
+  SFtype a;
 
-  FP_FROM_INT_S(A, i, 32, int);
-  FP_PACK_S(a, A);
+  FP_FROM_INT_S(A, i, SI_BITS, USItype);
+  FP_PACK_RAW_S(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/floatunsitf.c b/soft-fp/floatunsitf.c
index efb66e9..afc3b78 100644
--- a/soft-fp/floatunsitf.c
+++ b/soft-fp/floatunsitf.c
@@ -23,15 +23,15 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double
+TFtype
 __floatunsitf(USItype i)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
-  long double a;
+  TFtype a;
 
-  FP_FROM_INT_Q(A, i, 32, int);
-  FP_PACK_Q(a, A);
+  FP_FROM_INT_Q(A, i, SI_BITS, USItype);
+  FP_PACK_RAW_Q(a, A);
   FP_HANDLE_EXCEPTIONS;
 
   return a;
diff --git a/soft-fp/gedf2.c b/soft-fp/gedf2.c
index 66762d0..b3af2f1 100644
--- a/soft-fp/gedf2.c
+++ b/soft-fp/gedf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 iff a > b, -2 iff a ? b, -1 iff a < b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "double.h"
 
-int __gedf2(double a, double b)
+int __gedf2(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B);
diff --git a/soft-fp/gesf2.c b/soft-fp/gesf2.c
index bc5f431..d1cdbec 100644
--- a/soft-fp/gesf2.c
+++ b/soft-fp/gesf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 iff a > b, -2 iff a ? b, -1 iff a < b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "single.h"
 
-int __gesf2(float a, float b)
+int __gesf2(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B);
diff --git a/soft-fp/getf2.c b/soft-fp/getf2.c
index 40a3a51..51aa7de 100644
--- a/soft-fp/getf2.c
+++ b/soft-fp/getf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 iff a > b, -2 iff a ? b, -1 iff a < b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-int __getf2(long double a, long double b)
+int __getf2(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B);
diff --git a/soft-fp/ledf2.c b/soft-fp/ledf2.c
index 70d849a..f5efaaa 100644
--- a/soft-fp/ledf2.c
+++ b/soft-fp/ledf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 iff a > b, 2 iff a ? b, -1 iff a < b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "double.h"
 
-int __ledf2(double a, double b)
+int __ledf2(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B);
diff --git a/soft-fp/lesf2.c b/soft-fp/lesf2.c
index 31c07e6..86e0c87 100644
--- a/soft-fp/lesf2.c
+++ b/soft-fp/lesf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 iff a > b, 2 iff a ? b, -1 iff a < b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "single.h"
 
-int __lesf2(float a, float b)
+int __lesf2(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B);
diff --git a/soft-fp/letf2.c b/soft-fp/letf2.c
index 883745f..339ee03 100644
--- a/soft-fp/letf2.c
+++ b/soft-fp/letf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return 0 iff a == b, 1 iff a > b, 2 iff a ? b, -1 iff a < b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,7 +23,7 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-int __letf2(long double a, long double b)
+int __letf2(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B);
diff --git a/soft-fp/muldf3.c b/soft-fp/muldf3.c
index c1521ef..e6f8a0f 100644
--- a/soft-fp/muldf3.c
+++ b/soft-fp/muldf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a * b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __muldf3(double a, double b)
+DFtype __muldf3(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_D(A, a);
diff --git a/soft-fp/mulsf3.c b/soft-fp/mulsf3.c
index 48b215b..b493df8 100644
--- a/soft-fp/mulsf3.c
+++ b/soft-fp/mulsf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a * b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __mulsf3(float a, float b)
+SFtype __mulsf3(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_S(A, a);
diff --git a/soft-fp/multf3.c b/soft-fp/multf3.c
index b54eb1a..067ff1a 100644
--- a/soft-fp/multf3.c
+++ b/soft-fp/multf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a * b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __multf3(long double a, long double b)
+TFtype __multf3(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_Q(A, a);
diff --git a/soft-fp/negdf2.c b/soft-fp/negdf2.c
index cc287c5..cc3ce78 100644
--- a/soft-fp/negdf2.c
+++ b/soft-fp/negdf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return -a
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __negdf2(double a)
+DFtype __negdf2(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_UNPACK_D(A, a);
   FP_NEG_D(R, A);
diff --git a/soft-fp/negsf2.c b/soft-fp/negsf2.c
index 15bfef4..48ac33b 100644
--- a/soft-fp/negsf2.c
+++ b/soft-fp/negsf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return -a
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __negsf2(float a)
+SFtype __negsf2(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_UNPACK_S(A, a);
   FP_NEG_S(R, A);
diff --git a/soft-fp/negtf2.c b/soft-fp/negtf2.c
index f3eba5f..38fbe97 100644
--- a/soft-fp/negtf2.c
+++ b/soft-fp/negtf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return -a
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __negtf2(long double a)
+TFtype __negtf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_UNPACK_Q(A, a);
   FP_NEG_Q(R, A);
diff --git a/soft-fp/op-1.h b/soft-fp/op-1.h
index 367ff22..9f58ba6 100644
--- a/soft-fp/op-1.h
+++ b/soft-fp/op-1.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Basic one-word fraction declaration and manipulation.
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz),
@@ -40,8 +40,16 @@
 #define _FP_FRAC_SRL_1(X,N)	(X##_f >>= N)
 
 /* Right shift with sticky-lsb.  */
+#define _FP_FRAC_SRST_1(X,S,N,sz)	__FP_FRAC_SRST_1(X##_f, S, N, sz)
 #define _FP_FRAC_SRS_1(X,N,sz)	__FP_FRAC_SRS_1(X##_f, N, sz)
 
+#define __FP_FRAC_SRST_1(X,S,N,sz)			\
+do {							\
+  S = (__builtin_constant_p(N) && (N) == 1		\
+       ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0);	\
+  X = X >> (N);						\
+} while (0)
+
 #define __FP_FRAC_SRS_1(X,N,sz)						\
    (X = (X >> (N) | (__builtin_constant_p(N) && (N) == 1		\
 		     ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0)))
@@ -282,17 +290,4 @@
  * Convert FP values between word sizes
  */
 
-#define _FP_FRAC_CONV_1_1(dfs, sfs, D, S)				\
-  do {									\
-    D##_f = S##_f;							\
-    if (_FP_WFRACBITS_##sfs > _FP_WFRACBITS_##dfs)			\
-      {									\
-	if (S##_c != FP_CLS_NAN)					\
-	  _FP_FRAC_SRS_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs),	\
-			 _FP_WFRACBITS_##sfs);				\
-	else								\
-	  _FP_FRAC_SRL_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs));	\
-      }									\
-    else								\
-      D##_f <<= _FP_WFRACBITS_##dfs - _FP_WFRACBITS_##sfs;		\
-  } while (0)
+#define _FP_FRAC_COPY_1_1(D, S)		(D##_f = S##_f)
diff --git a/soft-fp/op-2.h b/soft-fp/op-2.h
index 89da27f..d8b89ff 100644
--- a/soft-fp/op-2.h
+++ b/soft-fp/op-2.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Basic two-word fraction declaration and manipulation.
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz),
@@ -29,61 +29,74 @@
 #define _FP_FRAC_LOW_2(X)	(X##_f0)
 #define _FP_FRAC_WORD_2(X,w)	(X##_f##w)
 
-#define _FP_FRAC_SLL_2(X,N)						\
-  do {									\
-    if ((N) < _FP_W_TYPE_SIZE)						\
-      {									\
-	if (__builtin_constant_p(N) && (N) == 1) 			\
-	  {								\
-	    X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE)(X##_f0)) < 0);	\
-	    X##_f0 += X##_f0;						\
-	  }								\
-	else								\
-	  {								\
-	    X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N));	\
-	    X##_f0 <<= (N);						\
-	  }								\
-      }									\
-    else								\
-      {									\
-	X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE);			\
-	X##_f0 = 0;							\
-      }									\
-  } while (0)
+#define _FP_FRAC_SLL_2(X,N)						    \
+(void)(((N) < _FP_W_TYPE_SIZE)						    \
+       ? ({								    \
+	    if (__builtin_constant_p(N) && (N) == 1)			    \
+	      {								    \
+		X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE)(X##_f0)) < 0);   \
+		X##_f0 += X##_f0;					    \
+	      }								    \
+	    else							    \
+	      {								    \
+		X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N)); \
+		X##_f0 <<= (N);						    \
+	      }								    \
+	    0;								    \
+	  })								    \
+       : ({								    \
+	    X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE);			    \
+	    X##_f0 = 0;							    \
+	  }))
+
 
 #define _FP_FRAC_SRL_2(X,N)						\
-  do {									\
-    if ((N) < _FP_W_TYPE_SIZE)						\
-      {									\
-	X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N));	\
-	X##_f1 >>= (N);							\
-      }									\
-    else								\
-      {									\
-	X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE);			\
-	X##_f1 = 0;							\
-      }									\
-  } while (0)
+(void)(((N) < _FP_W_TYPE_SIZE)						\
+       ? ({								\
+	    X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N));	\
+	    X##_f1 >>= (N);						\
+	  })								\
+       : ({								\
+	    X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE);			\
+	    X##_f1 = 0;							\
+	  }))
 
 /* Right shift with sticky-lsb.  */
-#define _FP_FRAC_SRS_2(X,N,sz)						\
-  do {									\
-    if ((N) < _FP_W_TYPE_SIZE)						\
-      {									\
-	X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) |	\
-		  (__builtin_constant_p(N) && (N) == 1			\
-		   ? X##_f0 & 1						\
-		   : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0));	\
-	X##_f1 >>= (N);							\
-      }									\
-    else								\
-      {									\
-	X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE) |			\
-		  (((X##_f1 << (2*_FP_W_TYPE_SIZE - (N))) |		\
-		    X##_f0) != 0));					\
-	X##_f1 = 0;							\
-      }									\
-  } while (0)
+#define _FP_FRAC_SRST_2(X,S, N,sz)					  \
+(void)(((N) < _FP_W_TYPE_SIZE)						  \
+       ? ({								  \
+	    S = (__builtin_constant_p(N) && (N) == 1			  \
+		 ? X##_f0 & 1						  \
+		 : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0);		  \
+	    X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N)); \
+	    X##_f1 >>= (N);						  \
+	  })								  \
+       : ({								  \
+	    S = ((((N) == _FP_W_TYPE_SIZE				  \
+		   ? 0							  \
+		   : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))		  \
+		  | X##_f0) != 0);					  \
+	    X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE));		  \
+	    X##_f1 = 0;							  \
+	  }))
+
+#define _FP_FRAC_SRS_2(X,N,sz)						  \
+(void)(((N) < _FP_W_TYPE_SIZE)						  \
+       ? ({								  \
+	    X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) | \
+		      (__builtin_constant_p(N) && (N) == 1		  \
+		       ? X##_f0 & 1					  \
+		       : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0));	  \
+	    X##_f1 >>= (N);						  \
+	  })								  \
+       : ({								  \
+	    X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE) |		  \
+		      ((((N) == _FP_W_TYPE_SIZE				  \
+			 ? 0						  \
+			 : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))	  \
+			| X##_f0) != 0));				  \
+	    X##_f1 = 0;							  \
+	  }))
 
 #define _FP_FRAC_ADDI_2(X,I)	\
   __FP_FRAC_ADDI_2(X##_f1, X##_f0, I)
@@ -115,9 +128,9 @@
 #define _FP_FRAC_CLEAR_OVERP_2(fs,X)	(_FP_FRAC_HIGH_##fs(X) &= ~_FP_OVERFLOW_##fs)
 #define _FP_FRAC_EQ_2(X, Y)	(X##_f1 == Y##_f1 && X##_f0 == Y##_f0)
 #define _FP_FRAC_GT_2(X, Y)	\
-  (X##_f1 > Y##_f1 || X##_f1 == Y##_f1 && X##_f0 > Y##_f0)
+  (X##_f1 > Y##_f1 || (X##_f1 == Y##_f1 && X##_f0 > Y##_f0))
 #define _FP_FRAC_GE_2(X, Y)	\
-  (X##_f1 > Y##_f1 || X##_f1 == Y##_f1 && X##_f0 >= Y##_f0)
+  (X##_f1 > Y##_f1 || (X##_f1 == Y##_f1 && X##_f0 >= Y##_f0))
 
 #define _FP_ZEROFRAC_2		0, 0
 #define _FP_MINFRAC_2		0, 1
@@ -570,16 +583,13 @@
  */
 
 #define _FP_FRAC_ASSEMBLE_2(r, X, rsize)	\
-  do {						\
-    if (rsize <= _FP_W_TYPE_SIZE)		\
-      r = X##_f0;				\
-    else					\
-      {						\
-	r = X##_f1;				\
-	r <<= _FP_W_TYPE_SIZE;			\
-	r += X##_f0;				\
-      }						\
-  } while (0)
+(void)((rsize <= _FP_W_TYPE_SIZE)		\
+       ? ({ r = X##_f0; })			\
+       : ({					\
+	    r = X##_f1;				\
+	    r <<= _FP_W_TYPE_SIZE;		\
+	    r += X##_f0;			\
+	  }))
 
 #define _FP_FRAC_DISASSEMBLE_2(X, r, rsize)				\
   do {									\
@@ -591,20 +601,6 @@
  * Convert FP values between word sizes
  */
 
-#define _FP_FRAC_CONV_1_2(dfs, sfs, D, S)				\
-  do {									\
-    if (S##_c != FP_CLS_NAN)						\
-      _FP_FRAC_SRS_2(S, (_FP_WFRACBITS_##sfs - _FP_WFRACBITS_##dfs),	\
-		     _FP_WFRACBITS_##sfs);				\
-    else								\
-      _FP_FRAC_SRL_2(S, (_FP_WFRACBITS_##sfs - _FP_WFRACBITS_##dfs));	\
-    D##_f = S##_f0;							\
-  } while (0)
-
-#define _FP_FRAC_CONV_2_1(dfs, sfs, D, S)				\
-  do {									\
-    D##_f0 = S##_f;							\
-    D##_f1 = 0;								\
-    _FP_FRAC_SLL_2(D, (_FP_WFRACBITS_##dfs - _FP_WFRACBITS_##sfs));	\
-  } while (0)
+#define _FP_FRAC_COPY_1_2(D, S)		(D##_f = S##_f0)
 
+#define _FP_FRAC_COPY_2_1(D, S)		((D##_f0 = S##_f), (D##_f1 = 0))
diff --git a/soft-fp/op-4.h b/soft-fp/op-4.h
index 404cb22..c0ffaaf 100644
--- a/soft-fp/op-4.h
+++ b/soft-fp/op-4.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Basic four-word fraction declaration and manipulation.
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz),
@@ -78,31 +78,36 @@
  * but that if any of the bits that fall off the right hand side
  * were one then we always set the LSbit.
  */
-#define _FP_FRAC_SRS_4(X,N,size)					\
-  do {									\
-    _FP_I_TYPE _up, _down, _skip, _i;					\
-    _FP_W_TYPE _s;							\
-    _skip = (N) / _FP_W_TYPE_SIZE;					\
-    _down = (N) % _FP_W_TYPE_SIZE;					\
-    _up = _FP_W_TYPE_SIZE - _down;					\
-    for (_s = _i = 0; _i < _skip; ++_i)					\
-      _s |= X##_f[_i];							\
-    _s |= X##_f[_i] << _up;						\
-/* s is now != 0 if we want to set the LSbit */				\
-    if (!_down)								\
-      for (_i = 0; _i <= 3-_skip; ++_i)					\
-	X##_f[_i] = X##_f[_i+_skip];					\
-    else								\
-      {									\
-	for (_i = 0; _i < 3-_skip; ++_i)				\
-	  X##_f[_i] = X##_f[_i+_skip] >> _down				\
-		      | X##_f[_i+_skip+1] << _up;			\
-	X##_f[_i++] = X##_f[3] >> _down;				\
-      }									\
-    for (; _i < 4; ++_i)						\
-      X##_f[_i] = 0;							\
-    /* don't fix the LSB until the very end when we're sure f[0] is stable */	\
-    X##_f[0] |= (_s != 0);						\
+#define _FP_FRAC_SRST_4(X,S,N,size)			\
+  do {							\
+    _FP_I_TYPE _up, _down, _skip, _i;			\
+    _FP_W_TYPE _s;					\
+    _skip = (N) / _FP_W_TYPE_SIZE;			\
+    _down = (N) % _FP_W_TYPE_SIZE;			\
+    _up = _FP_W_TYPE_SIZE - _down;			\
+    for (_s = _i = 0; _i < _skip; ++_i)			\
+      _s |= X##_f[_i];					\
+    if (!_down)						\
+      for (_i = 0; _i <= 3-_skip; ++_i)			\
+	X##_f[_i] = X##_f[_i+_skip];			\
+    else						\
+      {							\
+	_s |= X##_f[_i] << _up;				\
+	for (_i = 0; _i < 3-_skip; ++_i)		\
+	  X##_f[_i] = X##_f[_i+_skip] >> _down		\
+		      | X##_f[_i+_skip+1] << _up;	\
+	X##_f[_i++] = X##_f[3] >> _down;		\
+      }							\
+    for (; _i < 4; ++_i)				\
+      X##_f[_i] = 0;					\
+    S = (_s != 0);					\
+  } while (0)
+
+#define _FP_FRAC_SRS_4(X,N,size)		\
+  do {						\
+    int _sticky;				\
+    _FP_FRAC_SRST_4(X, _sticky, N, size);	\
+    X##_f[0] |= _sticky;			\
   } while (0)
 
 #define _FP_FRAC_ADD_4(R,X,Y)						\
@@ -512,7 +517,7 @@
 #ifndef __FP_FRAC_ADD_3
 #define __FP_FRAC_ADD_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
   do {								\
-    int _c1, _c2;							\
+    _FP_W_TYPE _c1, _c2;					\
     r0 = x0 + y0;						\
     _c1 = r0 < x0;						\
     r1 = x1 + y1;						\
@@ -526,7 +531,7 @@
 #ifndef __FP_FRAC_ADD_4
 #define __FP_FRAC_ADD_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
   do {								\
-    int _c1, _c2, _c3;						\
+    _FP_W_TYPE _c1, _c2, _c3;					\
     r0 = x0 + y0;						\
     _c1 = r0 < x0;						\
     r1 = x1 + y1;						\
@@ -544,7 +549,7 @@
 #ifndef __FP_FRAC_SUB_3
 #define __FP_FRAC_SUB_3(r2,r1,r0,x2,x1,x0,y2,y1,y0)		\
   do {								\
-    int _c1, _c2;							\
+    _FP_W_TYPE _c1, _c2;					\
     r0 = x0 - y0;						\
     _c1 = r0 > x0;						\
     r1 = x1 - y1;						\
@@ -558,7 +563,7 @@
 #ifndef __FP_FRAC_SUB_4
 #define __FP_FRAC_SUB_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0)	\
   do {								\
-    int _c1, _c2, _c3;						\
+    _FP_W_TYPE _c1, _c2, _c3;					\
     r0 = x0 - y0;						\
     _c1 = r0 > x0;						\
     r1 = x1 - y1;						\
@@ -609,26 +614,13 @@
  * internally [eg, that 2 word vars are X_f0 and x_f1]. But so do
  * the ones in op-2.h and op-1.h. 
  */
-#define _FP_FRAC_CONV_1_4(dfs, sfs, D, S)				\
-   do {									\
-     if (S##_c != FP_CLS_NAN)						\
-       _FP_FRAC_SRS_4(S, (_FP_WFRACBITS_##sfs - _FP_WFRACBITS_##dfs),	\
-			  _FP_WFRACBITS_##sfs);				\
-     else								\
-       _FP_FRAC_SRL_4(S, (_FP_WFRACBITS_##sfs - _FP_WFRACBITS_##dfs));	\
-     D##_f = S##_f[0];							\
-  } while (0)
+#define _FP_FRAC_COPY_1_4(D, S)		(D##_f = S##_f[0])
 
-#define _FP_FRAC_CONV_2_4(dfs, sfs, D, S)				\
-   do {									\
-     if (S##_c != FP_CLS_NAN)						\
-       _FP_FRAC_SRS_4(S, (_FP_WFRACBITS_##sfs - _FP_WFRACBITS_##dfs),	\
-		      _FP_WFRACBITS_##sfs);				\
-     else								\
-       _FP_FRAC_SRL_4(S, (_FP_WFRACBITS_##sfs - _FP_WFRACBITS_##dfs));	\
-     D##_f0 = S##_f[0];							\
-     D##_f1 = S##_f[1];							\
-  } while (0)
+#define _FP_FRAC_COPY_2_4(D, S)			\
+do {						\
+  D##_f0 = S##_f[0];				\
+  D##_f1 = S##_f[1];				\
+} while (0)
 
 /* Assembly/disassembly for converting to/from integral types.  
  * No shifting or overflow handled here.
@@ -671,18 +663,15 @@
     X##_f[3] = (rsize <= 3*_FP_W_TYPE_SIZE ? 0 : r >> 3*_FP_W_TYPE_SIZE); \
   } while (0);
 
-#define _FP_FRAC_CONV_4_1(dfs, sfs, D, S)				\
-   do {									\
-     D##_f[0] = S##_f;							\
-     D##_f[1] = D##_f[2] = D##_f[3] = 0;				\
-     _FP_FRAC_SLL_4(D, (_FP_WFRACBITS_##dfs - _FP_WFRACBITS_##sfs));	\
-   } while (0)
-
-#define _FP_FRAC_CONV_4_2(dfs, sfs, D, S)				\
-   do {									\
-     D##_f[0] = S##_f0;							\
-     D##_f[1] = S##_f1;							\
-     D##_f[2] = D##_f[3] = 0;						\
-     _FP_FRAC_SLL_4(D, (_FP_WFRACBITS_##dfs - _FP_WFRACBITS_##sfs));	\
-   } while (0)
-
+#define _FP_FRAC_COPY_4_1(D, S)			\
+do {						\
+  D##_f[0] = S##_f;				\
+  D##_f[1] = D##_f[2] = D##_f[3] = 0;		\
+} while (0)
+
+#define _FP_FRAC_COPY_4_2(D, S)			\
+do {						\
+  D##_f[0] = S##_f0;				\
+  D##_f[1] = S##_f1;				\
+  D##_f[2] = D##_f[3] = 0;			\
+} while (0)
diff --git a/soft-fp/op-8.h b/soft-fp/op-8.h
index 789d383..01d9235 100644
--- a/soft-fp/op-8.h
+++ b/soft-fp/op-8.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Basic eight-word fraction declaration and manipulation.
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz) and
@@ -83,13 +83,12 @@
     _up = _FP_W_TYPE_SIZE - _down;					\
     for (_s = _i = 0; _i < _skip; ++_i)					\
       _s |= X##_f[_i];							\
-    _s |= X##_f[_i] << _up;						\
-/* s is now != 0 if we want to set the LSbit */				\
     if (!_down)								\
       for (_i = 0; _i <= 7-_skip; ++_i)					\
 	X##_f[_i] = X##_f[_i+_skip];					\
     else								\
       {									\
+	_s |= X##_f[_i] << _up;						\
 	for (_i = 0; _i < 7-_skip; ++_i)				\
 	  X##_f[_i] = X##_f[_i+_skip] >> _down				\
 		      | X##_f[_i+_skip+1] << _up;			\
diff --git a/soft-fp/op-common.h b/soft-fp/op-common.h
index f30260e..957f71d 100644
--- a/soft-fp/op-common.h
+++ b/soft-fp/op-common.h
@@ -21,8 +21,8 @@
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
-#define _FP_DECL(wc, X)			\
-  _FP_I_TYPE X##_c, X##_s, X##_e;	\
+#define _FP_DECL(wc, X)						\
+  _FP_I_TYPE X##_c __attribute__((unused)), X##_s, X##_e;	\
   _FP_FRAC_DECL_##wc(X)
 
 /*
@@ -71,6 +71,87 @@ do {									\
   }									\
 } while (0)
 
+/* Finish unpacking an fp value in semi-raw mode: the mantissa is
+   shifted by _FP_WORKBITS but the implicit MSB is not inserted and
+   other classification is not done.  */
+#define _FP_UNPACK_SEMIRAW(fs, wc, X)	_FP_FRAC_SLL_##wc(X, _FP_WORKBITS)
+
+/* A semi-raw value has overflowed to infinity.  Adjust the mantissa
+   and exponent appropriately.  */
+#define _FP_OVERFLOW_SEMIRAW(fs, wc, X)			\
+do {							\
+  if (FP_ROUNDMODE == FP_RND_NEAREST			\
+      || (FP_ROUNDMODE == FP_RND_PINF && !X##_s)	\
+      || (FP_ROUNDMODE == FP_RND_MINF && X##_s))	\
+    {							\
+      X##_e = _FP_EXPMAX_##fs;				\
+      _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);		\
+    }							\
+  else							\
+    {							\
+      X##_e = _FP_EXPMAX_##fs - 1;			\
+      FP_SET_EXCEPTION(FP_EX_OVERFLOW);			\
+      FP_SET_EXCEPTION(FP_EX_INEXACT);			\
+      _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);		\
+    }							\
+} while (0)
+
+/* Check for a semi-raw value being a signaling NaN and raise the
+   invalid exception if so.  */
+#define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X)			\
+do {								\
+  if (X##_e == _FP_EXPMAX_##fs					\
+      && !_FP_FRAC_ZEROP_##wc(X)				\
+      && !(_FP_FRAC_HIGH_##fs(X) & _FP_QNANBIT_SH_##fs))	\
+    FP_SET_EXCEPTION(FP_EX_INVALID);				\
+} while (0)
+
+/* Choose a NaN result from an operation on two semi-raw NaN
+   values.  */
+#define _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP)			\
+do {									\
+  /* _FP_CHOOSENAN expects raw values, so shift as required.  */	\
+  _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);					\
+  _FP_FRAC_SRL_##wc(Y, _FP_WORKBITS);					\
+  _FP_CHOOSENAN(fs, wc, R, X, Y, OP);					\
+  _FP_FRAC_SLL_##wc(R, _FP_WORKBITS);					\
+} while (0)
+
+/* Test whether a biased exponent is normal (not zero or maximum).  */
+#define _FP_EXP_NORMAL(fs, wc, X)	(((X##_e + 1) & _FP_EXPMAX_##fs) > 1)
+
+/* Prepare to pack an fp value in semi-raw mode: the mantissa is
+   rounded and shifted right, with the rounding possibly increasing
+   the exponent (including changing a finite value to infinity).  */
+#define _FP_PACK_SEMIRAW(fs, wc, X)				\
+do {								\
+  _FP_ROUND(wc, X);						\
+  if (_FP_FRAC_HIGH_##fs(X)					\
+      & (_FP_OVERFLOW_##fs >> 1))				\
+    {								\
+      _FP_FRAC_HIGH_##fs(X) &= ~(_FP_OVERFLOW_##fs >> 1);	\
+      X##_e++;							\
+      if (X##_e == _FP_EXPMAX_##fs)				\
+	_FP_OVERFLOW_SEMIRAW(fs, wc, X);			\
+    }								\
+  _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);				\
+  if (!_FP_EXP_NORMAL(fs, wc, X) && !_FP_FRAC_ZEROP_##wc(X))	\
+    {								\
+      if (X##_e == 0)						\
+	FP_SET_EXCEPTION(FP_EX_UNDERFLOW);			\
+      else							\
+	{							\
+	  if (!_FP_KEEPNANFRACP)				\
+	    {							\
+	      _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);		\
+	      X##_s = _FP_NANSIGN_##fs;				\
+	    }							\
+	  else							\
+	    _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;	\
+	}							\
+    }								\
+} while (0)
+
 /*
  * Before packing the bits back into the native fp result, take care
  * of such mundane things as rounding and overflow.  Also, for some
@@ -202,153 +283,433 @@ do {								\
 
 
 
-/*
- * Main addition routine.  The input values should be cooked.
- */
-
-#define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP)				     \
-do {									     \
-  switch (_FP_CLS_COMBINE(X##_c, Y##_c))				     \
-  {									     \
-  case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL):			     \
-    {									     \
-      /* shift the smaller number so that its exponent matches the larger */ \
-      _FP_I_TYPE diff = X##_e - Y##_e;					     \
-									     \
-      if (diff < 0)							     \
-	{								     \
-	  diff = -diff;							     \
-	  if (diff <= _FP_WFRACBITS_##fs)				     \
-	    _FP_FRAC_SRS_##wc(X, diff, _FP_WFRACBITS_##fs);		     \
-	  else if (!_FP_FRAC_ZEROP_##wc(X))				     \
-	    _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);			     \
-	  R##_e = Y##_e;						     \
-	}								     \
-      else								     \
-	{								     \
-	  if (diff > 0)							     \
-	    {								     \
-	      if (diff <= _FP_WFRACBITS_##fs)				     \
-	        _FP_FRAC_SRS_##wc(Y, diff, _FP_WFRACBITS_##fs);		     \
-	      else if (!_FP_FRAC_ZEROP_##wc(Y))				     \
-	        _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc);			     \
-	    }								     \
-	  R##_e = X##_e;						     \
-	}								     \
-									     \
-      R##_c = FP_CLS_NORMAL;						     \
-									     \
-      if (X##_s == Y##_s)						     \
-	{								     \
-	  R##_s = X##_s;						     \
-	  _FP_FRAC_ADD_##wc(R, X, Y);					     \
-	  if (_FP_FRAC_OVERP_##wc(fs, R))				     \
-	    {								     \
-	      _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);		     \
-	      R##_e++;							     \
-	    }								     \
-	}								     \
-      else								     \
-	{								     \
-	  R##_s = X##_s;						     \
-	  _FP_FRAC_SUB_##wc(R, X, Y);					     \
-	  if (_FP_FRAC_ZEROP_##wc(R))					     \
-	    {								     \
-	      /* return an exact zero */				     \
-	      if (FP_ROUNDMODE == FP_RND_MINF)				     \
-		R##_s |= Y##_s;						     \
-	      else							     \
-		R##_s &= Y##_s;						     \
-	      R##_c = FP_CLS_ZERO;					     \
-	    }								     \
-	  else								     \
-	    {								     \
-	      if (_FP_FRAC_NEGP_##wc(R))				     \
-		{							     \
-		  _FP_FRAC_SUB_##wc(R, Y, X);				     \
-		  R##_s = Y##_s;					     \
-		}							     \
-									     \
-	      /* renormalize after subtraction */			     \
-	      _FP_FRAC_CLZ_##wc(diff, R);				     \
-	      diff -= _FP_WFRACXBITS_##fs;				     \
-	      if (diff)							     \
-		{							     \
-		  R##_e -= diff;					     \
-		  _FP_FRAC_SLL_##wc(R, diff);				     \
-		}							     \
-	    }								     \
-	}								     \
-      break;								     \
-    }									     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN):				     \
-    _FP_CHOOSENAN(fs, wc, R, X, Y, OP);					     \
-    break;								     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO):			     \
-    R##_e = X##_e;							     \
-  case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL):			     \
-  case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF):				     \
-  case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO):				     \
-    _FP_FRAC_COPY_##wc(R, X);						     \
-    R##_s = X##_s;							     \
-    R##_c = X##_c;							     \
-    break;								     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL):			     \
-    R##_e = Y##_e;							     \
-  case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN):			     \
-  case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN):				     \
-  case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN):				     \
-    _FP_FRAC_COPY_##wc(R, Y);						     \
-    R##_s = Y##_s;							     \
-    R##_c = Y##_c;							     \
-    break;								     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF):				     \
-    if (X##_s != Y##_s)							     \
-      {									     \
-	/* +INF + -INF => NAN */					     \
-	_FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);				     \
-	R##_s = _FP_NANSIGN_##fs;					     \
-	R##_c = FP_CLS_NAN;						     \
-	FP_SET_EXCEPTION(FP_EX_INVALID);				     \
-	break;								     \
-      }									     \
-    /* FALLTHRU */							     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL):			     \
-  case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO):				     \
-    R##_s = X##_s;							     \
-    R##_c = FP_CLS_INF;							     \
-    break;								     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF):			     \
-  case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF):				     \
-    R##_s = Y##_s;							     \
-    R##_c = FP_CLS_INF;							     \
-    break;								     \
-									     \
-  case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO):			     \
-    /* make sure the sign is correct */					     \
-    if (FP_ROUNDMODE == FP_RND_MINF)					     \
-      R##_s = X##_s | Y##_s;						     \
-    else								     \
-      R##_s = X##_s & Y##_s;						     \
-    R##_c = FP_CLS_ZERO;						     \
-    break;								     \
-									     \
-  default:								     \
-    abort();								     \
-  }									     \
+/* Addition on semi-raw values.  */
+#define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP)				 \
+do {									 \
+  if (X##_s == Y##_s)							 \
+    {									 \
+      /* Addition.  */							 \
+      R##_s = X##_s;							 \
+      int ediff = X##_e - Y##_e;					 \
+      if (ediff > 0)							 \
+	{								 \
+	  R##_e = X##_e;						 \
+	  if (Y##_e == 0)						 \
+	    {								 \
+	      /* Y is zero or denormalized.  */				 \
+	      if (_FP_FRAC_ZEROP_##wc(Y))				 \
+		{							 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
+		  _FP_FRAC_COPY_##wc(R, X);				 \
+		  goto add_done;					 \
+		}							 \
+	      else							 \
+		{							 \
+		  FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		  ediff--;						 \
+		  if (ediff == 0)					 \
+		    {							 \
+		      _FP_FRAC_ADD_##wc(R, X, Y);			 \
+		      goto add3;					 \
+		    }							 \
+		  if (X##_e == _FP_EXPMAX_##fs)				 \
+		    {							 \
+		      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);		 \
+		      _FP_FRAC_COPY_##wc(R, X);				 \
+		      goto add_done;					 \
+		    }							 \
+		  goto add1;						 \
+		}							 \
+	    }								 \
+	  else if (X##_e == _FP_EXPMAX_##fs)				 \
+	    {								 \
+	      /* X is NaN or Inf, Y is normal.  */			 \
+	      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
+	      _FP_FRAC_COPY_##wc(R, X);					 \
+	      goto add_done;						 \
+	    }								 \
+									 \
+	  /* Insert implicit MSB of Y.  */				 \
+	  _FP_FRAC_HIGH_##fs(Y) |= _FP_IMPLBIT_SH_##fs;			 \
+									 \
+	add1:								 \
+	  /* Shift the mantissa of Y to the right EDIFF steps;		 \
+	     remember to account later for the implicit MSB of X.  */	 \
+	  if (ediff <= _FP_WFRACBITS_##fs)				 \
+	    _FP_FRAC_SRS_##wc(Y, ediff, _FP_WFRACBITS_##fs);		 \
+	  else if (!_FP_FRAC_ZEROP_##wc(Y))				 \
+	    _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc);			 \
+	  _FP_FRAC_ADD_##wc(R, X, Y);					 \
+	}								 \
+      else if (ediff < 0)						 \
+	{								 \
+	  ediff = -ediff;						 \
+	  R##_e = Y##_e;						 \
+	  if (X##_e == 0)						 \
+	    {								 \
+	      /* X is zero or denormalized.  */				 \
+	      if (_FP_FRAC_ZEROP_##wc(X))				 \
+		{							 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
+		  _FP_FRAC_COPY_##wc(R, Y);				 \
+		  goto add_done;					 \
+		}							 \
+	      else							 \
+		{							 \
+		  FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		  ediff--;						 \
+		  if (ediff == 0)					 \
+		    {							 \
+		      _FP_FRAC_ADD_##wc(R, Y, X);			 \
+		      goto add3;					 \
+		    }							 \
+		  if (Y##_e == _FP_EXPMAX_##fs)				 \
+		    {							 \
+		      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);		 \
+		      _FP_FRAC_COPY_##wc(R, Y);				 \
+		      goto add_done;					 \
+		    }							 \
+		  goto add2;						 \
+		}							 \
+	    }								 \
+	  else if (Y##_e == _FP_EXPMAX_##fs)				 \
+	    {								 \
+	      /* Y is NaN or Inf, X is normal.  */			 \
+	      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
+	      _FP_FRAC_COPY_##wc(R, Y);					 \
+	      goto add_done;						 \
+	    }								 \
+									 \
+	  /* Insert implicit MSB of X.  */				 \
+	  _FP_FRAC_HIGH_##fs(X) |= _FP_IMPLBIT_SH_##fs;			 \
+									 \
+	add2:								 \
+	  /* Shift the mantissa of X to the right EDIFF steps;		 \
+	     remember to account later for the implicit MSB of Y.  */	 \
+	  if (ediff <= _FP_WFRACBITS_##fs)				 \
+	    _FP_FRAC_SRS_##wc(X, ediff, _FP_WFRACBITS_##fs);		 \
+	  else if (!_FP_FRAC_ZEROP_##wc(X))				 \
+	    _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);			 \
+	  _FP_FRAC_ADD_##wc(R, Y, X);					 \
+	}								 \
+      else								 \
+	{								 \
+	  /* ediff == 0.  */						 \
+	  if (!_FP_EXP_NORMAL(fs, wc, X))				 \
+	    {								 \
+	      if (X##_e == 0)						 \
+		{							 \
+		  /* X and Y are zero or denormalized.  */		 \
+		  R##_e = 0;						 \
+		  if (_FP_FRAC_ZEROP_##wc(X))				 \
+		    {							 \
+		      if (!_FP_FRAC_ZEROP_##wc(Y))			 \
+			FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		      _FP_FRAC_COPY_##wc(R, Y);				 \
+		      goto add_done;					 \
+		    }							 \
+		  else if (_FP_FRAC_ZEROP_##wc(Y))			 \
+		    {							 \
+		      FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		      _FP_FRAC_COPY_##wc(R, X);				 \
+		      goto add_done;					 \
+		    }							 \
+		  else							 \
+		    {							 \
+		      FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		      _FP_FRAC_ADD_##wc(R, X, Y);			 \
+		      if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)	 \
+			{						 \
+			  /* Normalized result.  */			 \
+			  _FP_FRAC_HIGH_##fs(R)				 \
+			    &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs;	 \
+			  R##_e = 1;					 \
+			}						 \
+		      goto add_done;					 \
+		    }							 \
+		}							 \
+	      else							 \
+		{							 \
+		  /* X and Y are NaN or Inf.  */			 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
+		  R##_e = _FP_EXPMAX_##fs;				 \
+		  if (_FP_FRAC_ZEROP_##wc(X))				 \
+		    _FP_FRAC_COPY_##wc(R, Y);				 \
+		  else if (_FP_FRAC_ZEROP_##wc(Y))			 \
+		    _FP_FRAC_COPY_##wc(R, X);				 \
+		  else							 \
+		    _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP);		 \
+		  goto add_done;					 \
+		}							 \
+	    }								 \
+	  /* The exponents of X and Y, both normal, are equal.  The	 \
+	     implicit MSBs will always add to increase the		 \
+	     exponent.  */						 \
+	  _FP_FRAC_ADD_##wc(R, X, Y);					 \
+	  R##_e = X##_e + 1;						 \
+	  _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);			 \
+	  if (R##_e == _FP_EXPMAX_##fs)					 \
+	    /* Overflow to infinity (depending on rounding mode).  */	 \
+	    _FP_OVERFLOW_SEMIRAW(fs, wc, R);				 \
+	  goto add_done;						 \
+	}								 \
+    add3:								 \
+      if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)			 \
+	{								 \
+	  /* Overflow.  */						 \
+	  _FP_FRAC_HIGH_##fs(R) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs;	 \
+	  R##_e++;							 \
+	  _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs);			 \
+	  if (R##_e == _FP_EXPMAX_##fs)					 \
+	    /* Overflow to infinity (depending on rounding mode).  */	 \
+	    _FP_OVERFLOW_SEMIRAW(fs, wc, R);				 \
+	}								 \
+    add_done: ;								 \
+    }									 \
+  else									 \
+    {									 \
+      /* Subtraction.  */						 \
+      int ediff = X##_e - Y##_e;					 \
+      if (ediff > 0)							 \
+	{								 \
+	  R##_e = X##_e;						 \
+	  R##_s = X##_s;						 \
+	  if (Y##_e == 0)						 \
+	    {								 \
+	      /* Y is zero or denormalized.  */				 \
+	      if (_FP_FRAC_ZEROP_##wc(Y))				 \
+		{							 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
+		  _FP_FRAC_COPY_##wc(R, X);				 \
+		  goto sub_done;					 \
+		}							 \
+	      else							 \
+		{							 \
+		  FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		  ediff--;						 \
+		  if (ediff == 0)					 \
+		    {							 \
+		      _FP_FRAC_SUB_##wc(R, X, Y);			 \
+		      goto sub3;					 \
+		    }							 \
+		  if (X##_e == _FP_EXPMAX_##fs)				 \
+		    {							 \
+		      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);		 \
+		      _FP_FRAC_COPY_##wc(R, X);				 \
+		      goto sub_done;					 \
+		    }							 \
+		  goto sub1;						 \
+		}							 \
+	    }								 \
+	  else if (X##_e == _FP_EXPMAX_##fs)				 \
+	    {								 \
+	      /* X is NaN or Inf, Y is normal.  */			 \
+	      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
+	      _FP_FRAC_COPY_##wc(R, X);					 \
+	      goto sub_done;						 \
+	    }								 \
+									 \
+	  /* Insert implicit MSB of Y.  */				 \
+	  _FP_FRAC_HIGH_##fs(Y) |= _FP_IMPLBIT_SH_##fs;			 \
+									 \
+	sub1:								 \
+	  /* Shift the mantissa of Y to the right EDIFF steps;		 \
+	     remember to account later for the implicit MSB of X.  */	 \
+	  if (ediff <= _FP_WFRACBITS_##fs)				 \
+	    _FP_FRAC_SRS_##wc(Y, ediff, _FP_WFRACBITS_##fs);		 \
+	  else if (!_FP_FRAC_ZEROP_##wc(Y))				 \
+	    _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc);			 \
+	  _FP_FRAC_SUB_##wc(R, X, Y);					 \
+	}								 \
+      else if (ediff < 0)						 \
+	{								 \
+	  ediff = -ediff;						 \
+	  R##_e = Y##_e;						 \
+	  R##_s = Y##_s;						 \
+	  if (X##_e == 0)						 \
+	    {								 \
+	      /* X is zero or denormalized.  */				 \
+	      if (_FP_FRAC_ZEROP_##wc(X))				 \
+		{							 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
+		  _FP_FRAC_COPY_##wc(R, Y);				 \
+		  goto sub_done;					 \
+		}							 \
+	      else							 \
+		{							 \
+		  FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		  ediff--;						 \
+		  if (ediff == 0)					 \
+		    {							 \
+		      _FP_FRAC_SUB_##wc(R, Y, X);			 \
+		      goto sub3;					 \
+		    }							 \
+		  if (Y##_e == _FP_EXPMAX_##fs)				 \
+		    {							 \
+		      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);		 \
+		      _FP_FRAC_COPY_##wc(R, Y);				 \
+		      goto sub_done;					 \
+		    }							 \
+		  goto sub2;						 \
+		}							 \
+	    }								 \
+	  else if (Y##_e == _FP_EXPMAX_##fs)				 \
+	    {								 \
+	      /* Y is NaN or Inf, X is normal.  */			 \
+	      _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
+	      _FP_FRAC_COPY_##wc(R, Y);					 \
+	      goto sub_done;						 \
+	    }								 \
+									 \
+	  /* Insert implicit MSB of X.  */				 \
+	  _FP_FRAC_HIGH_##fs(X) |= _FP_IMPLBIT_SH_##fs;			 \
+									 \
+	sub2:								 \
+	  /* Shift the mantissa of X to the right EDIFF steps;		 \
+	     remember to account later for the implicit MSB of Y.  */	 \
+	  if (ediff <= _FP_WFRACBITS_##fs)				 \
+	    _FP_FRAC_SRS_##wc(X, ediff, _FP_WFRACBITS_##fs);		 \
+	  else if (!_FP_FRAC_ZEROP_##wc(X))				 \
+	    _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc);			 \
+	  _FP_FRAC_SUB_##wc(R, Y, X);					 \
+	}								 \
+      else								 \
+	{								 \
+	  /* ediff == 0.  */						 \
+	  if (!_FP_EXP_NORMAL(fs, wc, X))				 \
+	    {								 \
+	      if (X##_e == 0)						 \
+		{							 \
+		  /* X and Y are zero or denormalized.  */		 \
+		  R##_e = 0;						 \
+		  if (_FP_FRAC_ZEROP_##wc(X))				 \
+		    {							 \
+		      _FP_FRAC_COPY_##wc(R, Y);				 \
+		      if (_FP_FRAC_ZEROP_##wc(Y))			 \
+			R##_s = (FP_ROUNDMODE == FP_RND_MINF);		 \
+		      else						 \
+			{						 \
+			  FP_SET_EXCEPTION(FP_EX_DENORM);		 \
+			  R##_s = Y##_s;				 \
+			}						 \
+		      goto sub_done;					 \
+		    }							 \
+		  else if (_FP_FRAC_ZEROP_##wc(Y))			 \
+		    {							 \
+		      FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		      _FP_FRAC_COPY_##wc(R, X);				 \
+		      R##_s = X##_s;					 \
+		      goto sub_done;					 \
+		    }							 \
+		  else							 \
+		    {							 \
+		      FP_SET_EXCEPTION(FP_EX_DENORM);			 \
+		      _FP_FRAC_SUB_##wc(R, X, Y);			 \
+		      R##_s = X##_s;					 \
+		      if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)	 \
+			{						 \
+			  /* |X| < |Y|, negate result.  */		 \
+			  _FP_FRAC_SUB_##wc(R, Y, X);			 \
+			  R##_s = Y##_s;				 \
+			}						 \
+		      else if (_FP_FRAC_ZEROP_##wc(R))			 \
+			R##_s = (FP_ROUNDMODE == FP_RND_MINF);		 \
+		      goto sub_done;					 \
+		    }							 \
+		}							 \
+	      else							 \
+		{							 \
+		  /* X and Y are NaN or Inf, of opposite signs.  */	 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X);			 \
+		  _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, Y);			 \
+		  R##_e = _FP_EXPMAX_##fs;				 \
+		  if (_FP_FRAC_ZEROP_##wc(X))				 \
+		    {							 \
+		      if (_FP_FRAC_ZEROP_##wc(Y))			 \
+			{						 \
+			  /* Inf - Inf.  */				 \
+			  R##_s = _FP_NANSIGN_##fs;			 \
+			  _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs);	 \
+			  _FP_FRAC_SLL_##wc(R, _FP_WORKBITS);		 \
+			  FP_SET_EXCEPTION(FP_EX_INVALID);		 \
+			}						 \
+		      else						 \
+			{						 \
+			  /* Inf - NaN.  */				 \
+			  R##_s = Y##_s;				 \
+			  _FP_FRAC_COPY_##wc(R, Y);			 \
+			}						 \
+		    }							 \
+		  else							 \
+		    {							 \
+		      if (_FP_FRAC_ZEROP_##wc(Y))			 \
+			{						 \
+			  /* NaN - Inf.  */				 \
+			  R##_s = X##_s;				 \
+			  _FP_FRAC_COPY_##wc(R, X);			 \
+			}						 \
+		      else						 \
+			{						 \
+			  /* NaN - NaN.  */				 \
+			  _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP);	 \
+			}						 \
+		    }							 \
+		  goto sub_done;					 \
+		}							 \
+	    }								 \
+	  /* The exponents of X and Y, both normal, are equal.  The	 \
+	     implicit MSBs cancel.  */					 \
+	  R##_e = X##_e;						 \
+	  _FP_FRAC_SUB_##wc(R, X, Y);					 \
+	  R##_s = X##_s;						 \
+	  if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)		 \
+	    {								 \
+	      /* |X| < |Y|, negate result.  */				 \
+	      _FP_FRAC_SUB_##wc(R, Y, X);				 \
+	      R##_s = Y##_s;						 \
+	    }								 \
+	  else if (_FP_FRAC_ZEROP_##wc(R))				 \
+	    {								 \
+	      R##_e = 0;						 \
+	      R##_s = (FP_ROUNDMODE == FP_RND_MINF);			 \
+	      goto sub_done;						 \
+	    }								 \
+	  goto norm;							 \
+	}								 \
+    sub3:								 \
+      if (_FP_FRAC_HIGH_##fs(R) & _FP_IMPLBIT_SH_##fs)			 \
+	{								 \
+	  int diff;							 \
+	  /* Carry into most significant bit of larger one of X and Y,	 \
+	     canceling it; renormalize.  */				 \
+	  _FP_FRAC_HIGH_##fs(R) &= _FP_IMPLBIT_SH_##fs - 1;		 \
+	norm:								 \
+	  _FP_FRAC_CLZ_##wc(diff, R);					 \
+	  diff -= _FP_WFRACXBITS_##fs;					 \
+	  _FP_FRAC_SLL_##wc(R, diff);					 \
+	  if (R##_e <= diff)						 \
+	    {								 \
+	      /* R is denormalized.  */					 \
+	      diff = diff - R##_e + 1;					 \
+	      _FP_FRAC_SRS_##wc(R, diff, _FP_WFRACBITS_##fs);		 \
+	      R##_e = 0;						 \
+	    }								 \
+	  else								 \
+	    {								 \
+	      R##_e -= diff;						 \
+	      _FP_FRAC_HIGH_##fs(R) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs; \
+	    }								 \
+	}								 \
+    sub_done: ;								 \
+    }									 \
 } while (0)
 
 #define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL(fs, wc, R, X, Y, '+')
-#define _FP_SUB(fs, wc, R, X, Y)					     \
-  do {									     \
-    if (Y##_c != FP_CLS_NAN) Y##_s ^= 1;				     \
-    _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-');				     \
+#define _FP_SUB(fs, wc, R, X, Y)					    \
+  do {									    \
+    if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) Y##_s ^= 1; \
+    _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-');				    \
   } while (0)
 
 
@@ -537,20 +898,20 @@ do {							\
 
 /* Simplification for strict equality.  */
 
-#define _FP_CMP_EQ(fs, wc, ret, X, Y)					  \
-  do {									  \
-    /* NANs are unordered */						  \
-    if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))		  \
-	|| (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))	  \
-      {									  \
-	ret = 1;							  \
-      }									  \
-    else								  \
-      {									  \
-	ret = !(X##_e == Y##_e						  \
-		&& _FP_FRAC_EQ_##wc(X, Y)				  \
-		&& (X##_s == Y##_s || !X##_e && _FP_FRAC_ZEROP_##wc(X))); \
-      }									  \
+#define _FP_CMP_EQ(fs, wc, ret, X, Y)					    \
+  do {									    \
+    /* NANs are unordered */						    \
+    if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))		    \
+	|| (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y)))	    \
+      {									    \
+	ret = 1;							    \
+      }									    \
+    else								    \
+      {									    \
+	ret = !(X##_e == Y##_e						    \
+		&& _FP_FRAC_EQ_##wc(X, Y)				    \
+		&& (X##_s == Y##_s || (!X##_e && _FP_FRAC_ZEROP_##wc(X)))); \
+      }									    \
   } while (0)
 
 /* Version to test unordered.  */
@@ -616,115 +977,277 @@ do {									\
   } while (0)
 
 /*
- * Convert from FP to integer
+ * Convert from FP to integer.  Input is raw.
  */
 
 /* RSIGNED can have following values:
  * 0:  the number is required to be 0..(2^rsize)-1, if not, NV is set plus
- *     the result is either 0 or (2^rsize)-1 depending on the sign in such case.
- * 1:  the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is
- *     set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending
- *     on the sign in such case.
+ *     the result is either 0 or (2^rsize)-1 depending on the sign in such
+ *     case.
+ * 1:  the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not,
+ *     NV is set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1
+ *     depending on the sign in such case.
  * -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is
- *     set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending
- *     on the sign in such case.
+ *     set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1
+ *     depending on the sign in such case.
  */
-#define _FP_TO_INT(fs, wc, r, X, rsize, rsigned)				\
-  do {										\
-    switch (X##_c)								\
-      {										\
-      case FP_CLS_NORMAL:							\
-	if (X##_e < 0)								\
-	  {									\
-	    FP_SET_EXCEPTION(FP_EX_INEXACT);					\
-	  case FP_CLS_ZERO:							\
-	    r = 0;								\
-	  }									\
-	else if (X##_e >= rsize - (rsigned > 0 || X##_s)			\
-		 || (!rsigned && X##_s))					\
-	  {	/* overflow */							\
-	  case FP_CLS_NAN:                                                      \
-	  case FP_CLS_INF:							\
-	    if (rsigned)							\
-	      {									\
-		r = 1;								\
-		r <<= rsize - 1;						\
-		r -= 1 - X##_s;							\
-	      } else {								\
-		r = 0;								\
-		if (X##_s)							\
-		  r = ~r;							\
-	      }									\
-	    FP_SET_EXCEPTION(FP_EX_INVALID);					\
-	  }									\
-	else									\
-	  {									\
-	    if (_FP_W_TYPE_SIZE*wc < rsize)					\
-	      {									\
-		_FP_FRAC_ASSEMBLE_##wc(r, X, rsize);				\
-		r <<= X##_e - _FP_WFRACBITS_##fs;				\
-	      }									\
-	    else								\
-	      {									\
-		if (X##_e >= _FP_WFRACBITS_##fs)				\
-		  _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1));	\
-		else if (X##_e < _FP_WFRACBITS_##fs - 1)			\
-		  {								\
-		    _FP_FRAC_SRS_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 2),	\
-				      _FP_WFRACBITS_##fs);			\
-		    if (_FP_FRAC_LOW_##wc(X) & 1)				\
-		      FP_SET_EXCEPTION(FP_EX_INEXACT);				\
-		    _FP_FRAC_SRL_##wc(X, 1);					\
-		  }								\
-		_FP_FRAC_ASSEMBLE_##wc(r, X, rsize);				\
-	      }									\
-	    if (rsigned && X##_s)						\
-	      r = -r;								\
-	  }									\
-	break;									\
-      }										\
-  } while (0)
-
-#define _FP_FROM_INT(fs, wc, X, r, rsize, rtype)			\
-  do {									\
-    if (r)								\
-      {									\
-        unsigned rtype ur_;						\
-	X##_c = FP_CLS_NORMAL;						\
-									\
-	if ((X##_s = (r < 0)))						\
-	  r = -r;							\
-									\
-	ur_ = (unsigned rtype) r;					\
-	if (rsize <= _FP_W_TYPE_SIZE)					\
-	  __FP_CLZ(X##_e, ur_);						\
-	else								\
-	  __FP_CLZ_2(X##_e, (_FP_W_TYPE)(ur_ >> _FP_W_TYPE_SIZE), 	\
-		     (_FP_W_TYPE)ur_);					\
-	if (rsize < _FP_W_TYPE_SIZE)					\
-		X##_e -= (_FP_W_TYPE_SIZE - rsize);			\
-	X##_e = rsize - X##_e - 1;					\
+#define _FP_TO_INT(fs, wc, r, X, rsize, rsigned)			\
+do {									\
+  if (X##_e < _FP_EXPBIAS_##fs)						\
+    {									\
+      r = 0;								\
+      if (X##_e == 0)							\
+	{								\
+	  if (!_FP_FRAC_ZEROP_##wc(X))					\
+	    {								\
+	      FP_SET_EXCEPTION(FP_EX_INEXACT);				\
+	      FP_SET_EXCEPTION(FP_EX_DENORM);				\
+	    }								\
+	}								\
+      else								\
+	FP_SET_EXCEPTION(FP_EX_INEXACT);				\
+    }									\
+  else if (X##_e >= _FP_EXPBIAS_##fs + rsize - (rsigned > 0 || X##_s)	\
+	   || (!rsigned && X##_s))					\
+    {									\
+      /* Overflow or converting to the most negative integer.  */	\
+      if (rsigned)							\
+	{								\
+	  r = 1;							\
+	  r <<= rsize - 1;						\
+	  r -= 1 - X##_s;						\
+	} else {							\
+	  r = 0;							\
+	  if (X##_s)							\
+	    r = ~r;							\
+	}								\
 									\
-	if (_FP_FRACBITS_##fs < rsize && _FP_WFRACBITS_##fs < X##_e)	\
-	  __FP_FRAC_SRS_1(ur_, (X##_e - _FP_WFRACBITS_##fs + 1), rsize);\
-	_FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize);			\
-	if ((_FP_WFRACBITS_##fs - X##_e - 1) > 0)			\
-	  _FP_FRAC_SLL_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 1));	\
-      }									\
-    else								\
-      {									\
-	X##_c = FP_CLS_ZERO, X##_s = 0;					\
-      }									\
+      if (rsigned && X##_s && X##_e == _FP_EXPBIAS_##fs + rsize - 1)	\
+	{								\
+	  /* Possibly converting to most negative integer; check the	\
+	     mantissa.  */						\
+	  int inexact = 0;						\
+	  (void)((_FP_FRACBITS_##fs > rsize)				\
+		 ? ({ _FP_FRAC_SRST_##wc(X, inexact,			\
+					 _FP_FRACBITS_##fs - rsize,	\
+					 _FP_FRACBITS_##fs); 0; })	\
+		 : 0);							\
+	  if (!_FP_FRAC_ZEROP_##wc(X))					\
+	    FP_SET_EXCEPTION(FP_EX_INVALID);				\
+	  else if (inexact)						\
+	    FP_SET_EXCEPTION(FP_EX_INEXACT);				\
+	}								\
+      else								\
+	FP_SET_EXCEPTION(FP_EX_INVALID);				\
+    }									\
+  else									\
+    {									\
+      _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs;			\
+      if (X##_e >= _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1)		\
+	{								\
+	  _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);				\
+	  r <<= X##_e - _FP_EXPBIAS_##fs - _FP_FRACBITS_##fs + 1;	\
+	}								\
+      else								\
+	{								\
+	  int inexact;							\
+	  _FP_FRAC_SRST_##wc(X, inexact,				\
+			    (_FP_FRACBITS_##fs + _FP_EXPBIAS_##fs - 1	\
+			     - X##_e),					\
+			    _FP_FRACBITS_##fs);				\
+	  if (inexact)							\
+	    FP_SET_EXCEPTION(FP_EX_INEXACT);				\
+	  _FP_FRAC_ASSEMBLE_##wc(r, X, rsize);				\
+	}								\
+      if (rsigned && X##_s)						\
+	r = -r;								\
+    }									\
+} while (0)
+
+/* Convert integer to fp.  Output is raw.  RTYPE is unsigned even if
+   input is signed.  */
+#define _FP_FROM_INT(fs, wc, X, r, rsize, rtype)			     \
+  do {									     \
+    if (r)								     \
+      {									     \
+	rtype ur_;							     \
+									     \
+	if ((X##_s = (r < 0)))						     \
+	  r = -(rtype)r;						     \
+									     \
+	ur_ = (rtype) r;						     \
+	(void)((rsize <= _FP_W_TYPE_SIZE)				     \
+	       ? ({							     \
+		    int lz_;						     \
+		    __FP_CLZ(lz_, (_FP_W_TYPE)ur_);			     \
+		    X##_e = _FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1 - lz_;    \
+		  })							     \
+	       : ((rsize <= 2 * _FP_W_TYPE_SIZE)			     \
+		  ? ({							     \
+		       int lz_;						     \
+		       __FP_CLZ_2(lz_, (_FP_W_TYPE)(ur_ >> _FP_W_TYPE_SIZE), \
+				  (_FP_W_TYPE)ur_);			     \
+		       X##_e = (_FP_EXPBIAS_##fs + 2 * _FP_W_TYPE_SIZE - 1   \
+				- lz_);					     \
+		     })							     \
+		  : (abort(), 0)));					     \
+									     \
+	if (rsize - 1 + _FP_EXPBIAS_##fs >= _FP_EXPMAX_##fs		     \
+	    && X##_e >= _FP_EXPMAX_##fs)				     \
+	  {								     \
+	    /* Exponent too big; overflow to infinity.  (May also	     \
+	       happen after rounding below.)  */			     \
+	    _FP_OVERFLOW_SEMIRAW(fs, wc, X);				     \
+	    goto pack_semiraw;						     \
+	  }								     \
+									     \
+	if (rsize <= _FP_FRACBITS_##fs					     \
+	    || X##_e < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs)		     \
+	  {								     \
+	    /* Exactly representable; shift left.  */			     \
+	    _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize);			     \
+	    _FP_FRAC_SLL_##wc(X, (_FP_EXPBIAS_##fs			     \
+				  + _FP_FRACBITS_##fs - 1 - X##_e));	     \
+	  }								     \
+	else								     \
+	  {								     \
+	    /* More bits in integer than in floating type; need to	     \
+	       round.  */						     \
+	    if (_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 < X##_e)	     \
+	      ur_ = ((ur_ >> (X##_e - _FP_EXPBIAS_##fs			     \
+			      - _FP_WFRACBITS_##fs + 1))		     \
+		     | ((ur_ << (rsize - (X##_e - _FP_EXPBIAS_##fs	     \
+					  - _FP_WFRACBITS_##fs + 1)))	     \
+			!= 0));						     \
+	    _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize);			     \
+	    if ((_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 - X##_e) > 0)     \
+	      _FP_FRAC_SLL_##wc(X, (_FP_EXPBIAS_##fs			     \
+				    + _FP_WFRACBITS_##fs - 1 - X##_e));	     \
+	    _FP_FRAC_HIGH_##fs(X) &= ~(_FP_W_TYPE)_FP_IMPLBIT_SH_##fs;	     \
+	  pack_semiraw:							     \
+	    _FP_PACK_SEMIRAW(fs, wc, X);				     \
+	  }								     \
+      }									     \
+    else								     \
+      {									     \
+	X##_s = 0;							     \
+	X##_e = 0;							     \
+	_FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);			     \
+      }									     \
   } while (0)
 
 
-#define FP_CONV(dfs,sfs,dwc,swc,D,S)			\
-  do {							\
-    _FP_FRAC_CONV_##dwc##_##swc(dfs, sfs, D, S);	\
-    D##_e = S##_e;					\
-    D##_c = S##_c;					\
-    D##_s = S##_s;					\
-  } while (0)
+/* Extend from a narrower floating-point format to a wider one.  Input
+   and output are raw.  */
+#define FP_EXTEND(dfs,sfs,dwc,swc,D,S)					 \
+do {									 \
+  if (_FP_FRACBITS_##dfs < _FP_FRACBITS_##sfs				 \
+      || (_FP_EXPMAX_##dfs - _FP_EXPBIAS_##dfs				 \
+	  < _FP_EXPMAX_##sfs - _FP_EXPBIAS_##sfs)			 \
+      || _FP_EXPBIAS_##dfs < _FP_EXPBIAS_##sfs + _FP_FRACBITS_##sfs - 1) \
+    abort();								 \
+  D##_s = S##_s;							 \
+  _FP_FRAC_COPY_##dwc##_##swc(D, S);					 \
+  if (_FP_EXP_NORMAL(sfs, swc, S))					 \
+    {									 \
+      D##_e = S##_e + _FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs;		 \
+      _FP_FRAC_SLL_##dwc(D, (_FP_FRACBITS_##dfs - _FP_FRACBITS_##sfs));	 \
+    }									 \
+  else									 \
+    {									 \
+      if (S##_e == 0)							 \
+	{								 \
+	  if (_FP_FRAC_ZEROP_##swc(S))					 \
+	    D##_e = 0;							 \
+	  else								 \
+	    {								 \
+	      int _lz;							 \
+	      FP_SET_EXCEPTION(FP_EX_DENORM);				 \
+	      _FP_FRAC_CLZ_##swc(_lz, S);				 \
+	      _FP_FRAC_SLL_##dwc(D,					 \
+				 _lz + _FP_FRACBITS_##dfs		 \
+				 - _FP_FRACTBITS_##sfs);		 \
+	      D##_e = (_FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs + 1	 \
+		       + _FP_FRACXBITS_##sfs - _lz);			 \
+	    }								 \
+	}								 \
+      else								 \
+	{								 \
+	  D##_e = _FP_EXPMAX_##dfs;					 \
+	  if (!_FP_FRAC_ZEROP_##swc(S))					 \
+	    {								 \
+	      if (!(_FP_FRAC_HIGH_RAW_##sfs(S) & _FP_QNANBIT_##sfs))	 \
+		FP_SET_EXCEPTION(FP_EX_INVALID);			 \
+	      _FP_FRAC_SLL_##dwc(D, (_FP_FRACBITS_##dfs			 \
+				     - _FP_FRACBITS_##sfs));		 \
+	    }								 \
+	}								 \
+    }									 \
+} while (0)
+
+/* Truncate from a wider floating-point format to a narrower one.
+   Input and output are semi-raw.  */
+#define FP_TRUNC(dfs,sfs,dwc,swc,D,S)					     \
+do {									     \
+  if (_FP_FRACBITS_##sfs < _FP_FRACBITS_##dfs				     \
+      || _FP_EXPBIAS_##sfs < _FP_EXPBIAS_##dfs + _FP_FRACBITS_##dfs - 1)     \
+    abort();								     \
+  D##_s = S##_s;							     \
+  if (_FP_EXP_NORMAL(sfs, swc, S))					     \
+    {									     \
+      D##_e = S##_e + _FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs;		     \
+      if (D##_e >= _FP_EXPMAX_##dfs)					     \
+	_FP_OVERFLOW_SEMIRAW(dfs, dwc, D);				     \
+      else								     \
+	{								     \
+	  if (D##_e <= 0)						     \
+	    {								     \
+	      if (D##_e <= 1 - _FP_FRACBITS_##dfs)			     \
+		_FP_FRAC_SET_##swc(S, _FP_ZEROFRAC_##swc);		     \
+	      else							     \
+		{							     \
+		  _FP_FRAC_HIGH_##sfs(S) |= _FP_IMPLBIT_SH_##sfs;	     \
+		  _FP_FRAC_SRS_##swc(S, (_FP_WFRACBITS_##sfs		     \
+					 - _FP_WFRACBITS_##dfs + 1 - D##_e), \
+				     _FP_WFRACBITS_##sfs);		     \
+		}							     \
+	      D##_e = 0;						     \
+	    }								     \
+	  else								     \
+	    _FP_FRAC_SRS_##swc(S, (_FP_WFRACBITS_##sfs			     \
+				   - _FP_WFRACBITS_##dfs),		     \
+			       _FP_WFRACBITS_##sfs);			     \
+	  _FP_FRAC_COPY_##dwc##_##swc(D, S);				     \
+	}								     \
+    }									     \
+  else									     \
+    {									     \
+      if (S##_e == 0)							     \
+	{								     \
+	  D##_e = 0;							     \
+	  _FP_FRAC_SET_##dwc(D, _FP_ZEROFRAC_##dwc);			     \
+	  if (!_FP_FRAC_ZEROP_##swc(S))					     \
+	    {								     \
+	      FP_SET_EXCEPTION(FP_EX_DENORM);				     \
+	      FP_SET_EXCEPTION(FP_EX_INEXACT);				     \
+	    }								     \
+	}								     \
+      else								     \
+	{								     \
+	  D##_e = _FP_EXPMAX_##dfs;					     \
+	  if (_FP_FRAC_ZEROP_##swc(S))					     \
+	    _FP_FRAC_SET_##dwc(D, _FP_ZEROFRAC_##dwc);			     \
+	  else								     \
+	    {								     \
+	      _FP_CHECK_SIGNAN_SEMIRAW(sfs, swc, S);			     \
+	      _FP_FRAC_SRL_##swc(S, (_FP_WFRACBITS_##sfs		     \
+				     - _FP_WFRACBITS_##dfs));		     \
+	      _FP_FRAC_COPY_##dwc##_##swc(D, S);			     \
+	      _FP_FRAC_HIGH_##dfs(D) |= _FP_QNANBIT_SH_##dfs;		     \
+	    }								     \
+	}								     \
+    }									     \
+} while (0)
 
 /*
  * Helper primitives.
diff --git a/soft-fp/quad.h b/soft-fp/quad.h
index c1dccc4..578f17e 100644
--- a/soft-fp/quad.h
+++ b/soft-fp/quad.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Definitions for IEEE Quad Precision.
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz),
@@ -42,16 +42,22 @@
 
 #define _FP_QNANBIT_Q		\
 	((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-2) % _FP_W_TYPE_SIZE)
+#define _FP_QNANBIT_SH_Q		\
+	((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_IMPLBIT_Q		\
 	((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-1) % _FP_W_TYPE_SIZE)
+#define _FP_IMPLBIT_SH_Q		\
+	((_FP_W_TYPE)1 << (_FP_FRACBITS_Q-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
 #define _FP_OVERFLOW_Q		\
 	((_FP_W_TYPE)1 << (_FP_WFRACBITS_Q % _FP_W_TYPE_SIZE))
 
+typedef float TFtype __attribute__((mode(TF)));
+
 #if _FP_W_TYPE_SIZE < 64
 
 union _FP_UNION_Q
 {
-   long double flt;
+   TFtype flt;
    struct 
    {
 #if __BYTE_ORDER == __BIG_ENDIAN
@@ -95,6 +101,18 @@ union _FP_UNION_Q
     _FP_UNPACK_CANONICAL(Q,4,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_Q(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_4(Q,X,val);		\
+    _FP_UNPACK_SEMIRAW(Q,4,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_QP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_4_P(Q,X,val);	\
+    _FP_UNPACK_SEMIRAW(Q,4,X);		\
+  } while (0)
+
 #define FP_PACK_Q(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(Q,4,X);		\
@@ -108,6 +126,19 @@ union _FP_UNION_Q
       _FP_PACK_RAW_4_P(Q,val,X);	\
   } while (0)
 
+#define FP_PACK_SEMIRAW_Q(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(Q,4,X);		\
+    _FP_PACK_RAW_4(Q,val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_QP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(Q,4,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_4_P(Q,val,X);	\
+  } while (0)
+
 #define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,4,X)
 #define FP_NEG_Q(R,X)			_FP_NEG(Q,4,R,X)
 #define FP_ADD_Q(R,X,Y)			_FP_ADD(Q,4,R,X,Y)
@@ -130,7 +161,7 @@ union _FP_UNION_Q
 #else   /* not _FP_W_TYPE_SIZE < 64 */
 union _FP_UNION_Q
 {
-  long double flt /* __attribute__((mode(TF))) */ ;
+  TFtype flt /* __attribute__((mode(TF))) */ ;
   struct {
     _FP_W_TYPE a, b;
   } longs;
@@ -171,6 +202,18 @@ union _FP_UNION_Q
     _FP_UNPACK_CANONICAL(Q,2,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_Q(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_2(Q,X,val);		\
+    _FP_UNPACK_SEMIRAW(Q,2,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_QP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_2_P(Q,X,val);	\
+    _FP_UNPACK_SEMIRAW(Q,2,X);		\
+  } while (0)
+
 #define FP_PACK_Q(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(Q,2,X);		\
@@ -184,6 +227,19 @@ union _FP_UNION_Q
       _FP_PACK_RAW_2_P(Q,val,X);	\
   } while (0)
 
+#define FP_PACK_SEMIRAW_Q(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(Q,2,X);		\
+    _FP_PACK_RAW_2(Q,val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_QP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(Q,2,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_2_P(Q,val,X);	\
+  } while (0)
+
 #define FP_ISSIGNAN_Q(X)		_FP_ISSIGNAN(Q,2,X)
 #define FP_NEG_Q(R,X)			_FP_NEG(Q,2,R,X)
 #define FP_ADD_Q(R,X,Y)			_FP_ADD(Q,2,R,X,Y)
diff --git a/soft-fp/single.h b/soft-fp/single.h
index 094dc3c..ffb3178 100644
--- a/soft-fp/single.h
+++ b/soft-fp/single.h
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Definitions for IEEE Single Precision.
-   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
 		  Jakub Jelinek (jj@ultra.linux.cz),
@@ -26,23 +26,29 @@
 #error "Here's a nickel kid.  Go buy yourself a real computer."
 #endif
 
+#define _FP_FRACTBITS_S		_FP_W_TYPE_SIZE
+
 #define _FP_FRACBITS_S		24
-#define _FP_FRACXBITS_S		(_FP_W_TYPE_SIZE - _FP_FRACBITS_S)
+#define _FP_FRACXBITS_S		(_FP_FRACTBITS_S - _FP_FRACBITS_S)
 #define _FP_WFRACBITS_S		(_FP_WORKBITS + _FP_FRACBITS_S)
-#define _FP_WFRACXBITS_S	(_FP_W_TYPE_SIZE - _FP_WFRACBITS_S)
+#define _FP_WFRACXBITS_S	(_FP_FRACTBITS_S - _FP_WFRACBITS_S)
 #define _FP_EXPBITS_S		8
 #define _FP_EXPBIAS_S		127
 #define _FP_EXPMAX_S		255
 #define _FP_QNANBIT_S		((_FP_W_TYPE)1 << (_FP_FRACBITS_S-2))
+#define _FP_QNANBIT_SH_S	((_FP_W_TYPE)1 << (_FP_FRACBITS_S-2+_FP_WORKBITS))
 #define _FP_IMPLBIT_S		((_FP_W_TYPE)1 << (_FP_FRACBITS_S-1))
+#define _FP_IMPLBIT_SH_S	((_FP_W_TYPE)1 << (_FP_FRACBITS_S-1+_FP_WORKBITS))
 #define _FP_OVERFLOW_S		((_FP_W_TYPE)1 << (_FP_WFRACBITS_S))
 
 /* The implementation of _FP_MUL_MEAT_S and _FP_DIV_MEAT_S should be
    chosen by the target machine.  */
 
+typedef float SFtype __attribute__((mode(SF)));
+
 union _FP_UNION_S
 {
-  float flt;
+  SFtype flt;
   struct {
 #if __BYTE_ORDER == __BIG_ENDIAN
     unsigned sign : 1;
@@ -78,6 +84,18 @@ union _FP_UNION_S
     _FP_UNPACK_CANONICAL(S,1,X);	\
   } while (0)
 
+#define FP_UNPACK_SEMIRAW_S(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_1(S,X,val);		\
+    _FP_UNPACK_SEMIRAW(S,1,X);		\
+  } while (0)
+
+#define FP_UNPACK_SEMIRAW_SP(X,val)	\
+  do {					\
+    _FP_UNPACK_RAW_1_P(S,X,val);	\
+    _FP_UNPACK_SEMIRAW(S,1,X);		\
+  } while (0)
+
 #define FP_PACK_S(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(S,1,X);		\
@@ -91,6 +109,19 @@ union _FP_UNION_S
       _FP_PACK_RAW_1_P(S,val,X);	\
   } while (0)
 
+#define FP_PACK_SEMIRAW_S(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(S,1,X);		\
+    _FP_PACK_RAW_1(S,val,X);		\
+  } while (0)
+
+#define FP_PACK_SEMIRAW_SP(val,X)	\
+  do {					\
+    _FP_PACK_SEMIRAW(S,1,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_1_P(S,val,X);	\
+  } while (0)
+
 #define FP_ISSIGNAN_S(X)		_FP_ISSIGNAN(S,1,X)
 #define FP_NEG_S(R,X)			_FP_NEG(S,1,R,X)
 #define FP_ADD_S(R,X,Y)			_FP_ADD(S,1,R,X,Y)
diff --git a/soft-fp/soft-fp.h b/soft-fp/soft-fp.h
index 24a9b33..4d4e5d5 100644
--- a/soft-fp/soft-fp.h
+++ b/soft-fp/soft-fp.h
@@ -1,5 +1,5 @@
 /* Software floating-point emulation.
-   Copyright (C) 1997,1998,1999,2000,2002,2003,2005
+   Copyright (C) 1997,1998,1999,2000,2002,2003,2005,2006
 	Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
@@ -25,11 +25,19 @@
 #ifndef SOFT_FP_H
 #define SOFT_FP_H
 
+#ifdef _LIBC
 #include <sfp-machine.h>
+#else
+#include "sfp-machine.h"
+#endif
 
 /* Allow sfp-machine to have its own byte order definitions. */
 #ifndef __BYTE_ORDER
+#ifdef _LIBC
 #include <endian.h>
+#else
+#error "endianness not defined by sfp-machine.h"
+#endif
 #endif
 
 #define _FP_WORKBITS		3
@@ -172,10 +180,21 @@ typedef unsigned int UHWtype __attribute__((mode(HI)));
 typedef USItype UHWtype;
 #endif
 
+#define SI_BITS		(__CHAR_BIT__ * (int)sizeof(SItype))
+#define DI_BITS		(__CHAR_BIT__ * (int)sizeof(DItype))
+
 #ifndef umul_ppmm
+#ifdef _LIBC
 #include <stdlib/longlong.h>
+#else
+#include "longlong.h"
+#endif
 #endif
 
+#ifdef _LIBC
 #include <stdlib.h>
+#else
+extern void abort (void);
+#endif
 
 #endif
diff --git a/soft-fp/sqrtdf2.c b/soft-fp/sqrtdf2.c
index 48efad9..b52cafd 100644
--- a/soft-fp/sqrtdf2.c
+++ b/soft-fp/sqrtdf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return sqrt(a)
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __sqrtdf2(double a)
+DFtype __sqrtdf2(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_D(A, a);
diff --git a/soft-fp/sqrtsf2.c b/soft-fp/sqrtsf2.c
index 1c8aead..436e8ce 100644
--- a/soft-fp/sqrtsf2.c
+++ b/soft-fp/sqrtsf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return sqrt(a)
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __sqrtsf2(float a)
+SFtype __sqrtsf2(SFtype a)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_S(A, a);
diff --git a/soft-fp/sqrttf2.c b/soft-fp/sqrttf2.c
index 241f42d..ac2ad6f 100644
--- a/soft-fp/sqrttf2.c
+++ b/soft-fp/sqrttf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return sqrt(a)
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,11 +23,11 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __sqrttf2(long double a)
+TFtype __sqrttf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
   FP_UNPACK_Q(A, a);
diff --git a/soft-fp/subdf3.c b/soft-fp/subdf3.c
index 11a3339..81a2585 100644
--- a/soft-fp/subdf3.c
+++ b/soft-fp/subdf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a - b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,17 +23,17 @@
 #include "soft-fp.h"
 #include "double.h"
 
-double __subdf3(double a, double b)
+DFtype __subdf3(DFtype a, DFtype b)
 {
   FP_DECL_EX;
   FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
-  FP_UNPACK_D(B, b);
+  FP_UNPACK_SEMIRAW_D(A, a);
+  FP_UNPACK_SEMIRAW_D(B, b);
   FP_SUB_D(R, A, B);
-  FP_PACK_D(r, R);
+  FP_PACK_SEMIRAW_D(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/subsf3.c b/soft-fp/subsf3.c
index 84d418b..843fb50 100644
--- a/soft-fp/subsf3.c
+++ b/soft-fp/subsf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a - b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,17 +23,17 @@
 #include "soft-fp.h"
 #include "single.h"
 
-float __subsf3(float a, float b)
+SFtype __subsf3(SFtype a, SFtype b)
 {
   FP_DECL_EX;
   FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_S(A, a);
-  FP_UNPACK_S(B, b);
+  FP_UNPACK_SEMIRAW_S(A, a);
+  FP_UNPACK_SEMIRAW_S(B, b);
   FP_SUB_S(R, A, B);
-  FP_PACK_S(r, R);
+  FP_PACK_SEMIRAW_S(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/subtf3.c b/soft-fp/subtf3.c
index 448d398..a8e2eea 100644
--- a/soft-fp/subtf3.c
+++ b/soft-fp/subtf3.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Return a - b
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -23,17 +23,17 @@
 #include "soft-fp.h"
 #include "quad.h"
 
-long double __subtf3(long double a, long double b)
+TFtype __subtf3(TFtype a, TFtype b)
 {
   FP_DECL_EX;
   FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
-  long double r;
+  TFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
-  FP_UNPACK_Q(B, b);
+  FP_UNPACK_SEMIRAW_Q(A, a);
+  FP_UNPACK_SEMIRAW_Q(B, b);
   FP_SUB_Q(R, A, B);
-  FP_PACK_Q(r, R);
+  FP_PACK_SEMIRAW_Q(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/truncdfsf2.c b/soft-fp/truncdfsf2.c
index f7459513..0e802d9 100644
--- a/soft-fp/truncdfsf2.c
+++ b/soft-fp/truncdfsf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Truncate IEEE double into IEEE single
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -24,21 +24,21 @@
 #include "single.h"
 #include "double.h"
 
-float __truncdfsf2(double a)
+SFtype __truncdfsf2(DFtype a)
 {
   FP_DECL_EX;
   FP_DECL_D(A);
   FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_D(A, a);
+  FP_UNPACK_SEMIRAW_D(A, a);
 #if _FP_W_TYPE_SIZE < _FP_FRACBITS_D
-  FP_CONV(S,D,1,2,R,A);
+  FP_TRUNC(S,D,1,2,R,A);
 #else
-  FP_CONV(S,D,1,1,R,A);
+  FP_TRUNC(S,D,1,1,R,A);
 #endif
-  FP_PACK_S(r, R);
+  FP_PACK_SEMIRAW_S(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/trunctfdf2.c b/soft-fp/trunctfdf2.c
index 18ce1d5..e88d476 100644
--- a/soft-fp/trunctfdf2.c
+++ b/soft-fp/trunctfdf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Truncate IEEE quad into IEEE double
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -24,21 +24,21 @@
 #include "double.h"
 #include "quad.h"
 
-double __trunctfdf2(long double a)
+DFtype __trunctfdf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
   FP_DECL_D(R);
-  double r;
+  DFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
+  FP_UNPACK_SEMIRAW_Q(A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_CONV(D,Q,2,4,R,A);
+  FP_TRUNC(D,Q,2,4,R,A);
 #else
-  FP_CONV(D,Q,1,2,R,A);
+  FP_TRUNC(D,Q,1,2,R,A);
 #endif
-  FP_PACK_D(r, R);
+  FP_PACK_SEMIRAW_D(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/trunctfsf2.c b/soft-fp/trunctfsf2.c
index 32d658a..0601cf0 100644
--- a/soft-fp/trunctfsf2.c
+++ b/soft-fp/trunctfsf2.c
@@ -1,6 +1,6 @@
 /* Software floating-point emulation.
    Truncate IEEE quad into IEEE single
-   Copyright (C) 1997,1999 Free Software Foundation, Inc.
+   Copyright (C) 1997,1999,2006 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com) and
 		  Jakub Jelinek (jj@ultra.linux.cz).
@@ -24,21 +24,21 @@
 #include "single.h"
 #include "quad.h"
 
-float __trunctfsf2(long double a)
+SFtype __trunctfsf2(TFtype a)
 {
   FP_DECL_EX;
   FP_DECL_Q(A);
   FP_DECL_S(R);
-  float r;
+  SFtype r;
 
   FP_INIT_ROUNDMODE;
-  FP_UNPACK_Q(A, a);
+  FP_UNPACK_SEMIRAW_Q(A, a);
 #if (2 * _FP_W_TYPE_SIZE) < _FP_FRACBITS_Q
-  FP_CONV(S,Q,1,4,R,A);
+  FP_TRUNC(S,Q,1,4,R,A);
 #else
-  FP_CONV(S,Q,1,2,R,A);
+  FP_TRUNC(S,Q,1,2,R,A);
 #endif
-  FP_PACK_S(r, R);
+  FP_PACK_SEMIRAW_S(r, R);
   FP_HANDLE_EXCEPTIONS;
 
   return r;
diff --git a/soft-fp/unorddf2.c b/soft-fp/unorddf2.c
index 35f3e67..c44b61d 100644
--- a/soft-fp/unorddf2.c
+++ b/soft-fp/unorddf2.c
@@ -23,7 +23,7 @@
 #include "double.h"
 
 int
-__unorddf2(double a, double b)
+__unorddf2(DFtype a, DFtype b)
 {
   FP_DECL_D(A); FP_DECL_D(B);
   int r;
diff --git a/soft-fp/unordsf2.c b/soft-fp/unordsf2.c
index e741b79..4924ddc 100644
--- a/soft-fp/unordsf2.c
+++ b/soft-fp/unordsf2.c
@@ -23,7 +23,7 @@
 #include "single.h"
 
 int
-__unordsf2(float a, float b)
+__unordsf2(SFtype a, SFtype b)
 {
   FP_DECL_S(A);
   FP_DECL_S(B);
diff --git a/soft-fp/unordtf2.c b/soft-fp/unordtf2.c
index 5e30ddb..f0e43c1 100644
--- a/soft-fp/unordtf2.c
+++ b/soft-fp/unordtf2.c
@@ -23,7 +23,7 @@
 #include "quad.h"
 
 int
-__unordtf2(long double a, long double b)
+__unordtf2(TFtype a, TFtype b)
 {
   FP_DECL_Q(A);
   FP_DECL_Q(B);