summary refs log tree commit diff
path: root/soft-fp
diff options
context:
space:
mode:
authorRoland McGrath <roland@gnu.org>2006-02-25 01:29:59 +0000
committerRoland McGrath <roland@gnu.org>2006-02-25 01:29:59 +0000
commitfe0b1e854ad32a69b26041031c3382b9eb772bb5 (patch)
tree85bf81081191070920c32671fa2d47f3242ce1e9 /soft-fp
parent03e81bcee66fe606d4f2b4b363b0fff47a29b247 (diff)
downloadglibc-fe0b1e854ad32a69b26041031c3382b9eb772bb5.tar.gz
glibc-fe0b1e854ad32a69b26041031c3382b9eb772bb5.tar.xz
glibc-fe0b1e854ad32a69b26041031c3382b9eb772bb5.zip
* 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.
Diffstat (limited to 'soft-fp')
-rw-r--r--soft-fp/adddf3.c12
-rw-r--r--soft-fp/addsf3.c12
-rw-r--r--soft-fp/addtf3.c12
-rw-r--r--soft-fp/divdf3.c6
-rw-r--r--soft-fp/divsf3.c6
-rw-r--r--soft-fp/divtf3.c6
-rw-r--r--soft-fp/double.h62
-rw-r--r--soft-fp/eqdf2.c4
-rw-r--r--soft-fp/eqsf2.c4
-rw-r--r--soft-fp/eqtf2.c4
-rw-r--r--soft-fp/extenddftf2.c14
-rw-r--r--soft-fp/extended.h62
-rw-r--r--soft-fp/extendsfdf2.c14
-rw-r--r--soft-fp/extendsftf2.c14
-rw-r--r--soft-fp/fixdfdi.c10
-rw-r--r--soft-fp/fixdfsi.c10
-rw-r--r--soft-fp/fixsfdi.c10
-rw-r--r--soft-fp/fixsfsi.c10
-rw-r--r--soft-fp/fixtfdi.c10
-rw-r--r--soft-fp/fixtfsi.c10
-rw-r--r--soft-fp/fixunsdfdi.c8
-rw-r--r--soft-fp/fixunsdfsi.c8
-rw-r--r--soft-fp/fixunssfdi.c8
-rw-r--r--soft-fp/fixunssfsi.c8
-rw-r--r--soft-fp/fixunstfdi.c8
-rw-r--r--soft-fp/fixunstfsi.c8
-rw-r--r--soft-fp/floatdidf.c10
-rw-r--r--soft-fp/floatdisf.c10
-rw-r--r--soft-fp/floatditf.c10
-rw-r--r--soft-fp/floatsidf.c10
-rw-r--r--soft-fp/floatsisf.c10
-rw-r--r--soft-fp/floatsitf.c10
-rw-r--r--soft-fp/floatundidf.c6
-rw-r--r--soft-fp/floatundisf.c6
-rw-r--r--soft-fp/floatunditf.c8
-rw-r--r--soft-fp/floatunsidf.c6
-rw-r--r--soft-fp/floatunsisf.c6
-rw-r--r--soft-fp/floatunsitf.c8
-rw-r--r--soft-fp/gedf2.c4
-rw-r--r--soft-fp/gesf2.c4
-rw-r--r--soft-fp/getf2.c4
-rw-r--r--soft-fp/ledf2.c4
-rw-r--r--soft-fp/lesf2.c4
-rw-r--r--soft-fp/letf2.c4
-rw-r--r--soft-fp/muldf3.c6
-rw-r--r--soft-fp/mulsf3.c6
-rw-r--r--soft-fp/multf3.c6
-rw-r--r--soft-fp/negdf2.c6
-rw-r--r--soft-fp/negsf2.c6
-rw-r--r--soft-fp/negtf2.c6
-rw-r--r--soft-fp/op-1.h25
-rw-r--r--soft-fp/op-2.h156
-rw-r--r--soft-fp/op-4.h117
-rw-r--r--soft-fp/op-8.h5
-rw-r--r--soft-fp/op-common.h1041
-rw-r--r--soft-fp/quad.h62
-rw-r--r--soft-fp/single.h39
-rw-r--r--soft-fp/soft-fp.h21
-rw-r--r--soft-fp/sqrtdf2.c6
-rw-r--r--soft-fp/sqrtsf2.c6
-rw-r--r--soft-fp/sqrttf2.c6
-rw-r--r--soft-fp/subdf3.c12
-rw-r--r--soft-fp/subsf3.c12
-rw-r--r--soft-fp/subtf3.c12
-rw-r--r--soft-fp/truncdfsf2.c14
-rw-r--r--soft-fp/trunctfdf2.c14
-rw-r--r--soft-fp/trunctfsf2.c14
-rw-r--r--soft-fp/unorddf2.c2
-rw-r--r--soft-fp/unordsf2.c2
-rw-r--r--soft-fp/unordtf2.c2
70 files changed, 1393 insertions, 675 deletions
diff --git a/soft-fp/adddf3.c b/soft-fp/adddf3.c
index 6802d13e37..269ef664c7 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 a1e7f0c10c..cfd9526ea6 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 b7348f5acc..f889a189b6 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 f8a479dce7..b45a91ce0c 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 9e9234fddf..d62c7c02b7 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 264af97cb0..842aa8116e 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 4d66c8d457..86fd8ada86 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 b2586bdb9c..d1eb97222f 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 d838b52396..371465f74d 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 adb1663edb..59479b47a0 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 53ac72cfca..e25cc5c822 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 d34df5d0ce..0f2060e970 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 a418f1967e..220caf930d 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 d2735ba1a5..412d2e877c 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 201014581f..537de101c6 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 9961d3d560..0607005108 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 f3fd2e77a1..d9ef9e843b 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 e8251d18b6..916b079387 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 fda412261d..73a1cc7cbf 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 da51cf951b..78bad0ee39 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 18bc61ca30..b350d95272 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 4060b5119a..c363e5fbce 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 6e4f5beb30..6a43cb88ef 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 5c3e99305e..3ddcee55de 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 a8ac454ce4..0bf5327d1c 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 812fb8ef26..387b9c615b 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 38303f292f..2c6800010f 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 d2a2af0947..36f05ee409 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 ef05dee109..03487adfcb 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 e136333d87..d11ddcc9f1 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 d68f5a8ac1..64006e691b 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 e982bb7b35..5a64c70bc2 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 03bda04e62..dcec2f8360 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 68aa90fbf7..a2437e4071 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 2f53f7d6e4..f0fd3af92d 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 2649adcb6d..b43ed35cd7 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 a7f21ca68b..16fbf1dddb 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 efb66e9f0a..afc3b7862b 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 66762d0c81..b3af2f16d8 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 bc5f431747..d1cdbec7d3 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 40a3a51e77..51aa7de370 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 70d849a1e2..f5efaaabd8 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 31c07e6e23..86e0c87a39 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 883745ffab..339ee0381f 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 c1521ef9d7..e6f8a0f108 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 48b215b7d6..b493df8609 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 b54eb1a767..067ff1a3f7 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 cc287c54fe..cc3ce78f56 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 15bfef4fc1..48ac33b914 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 f3eba5f21d..38fbe97d58 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 367ff2274b..9f58ba6a08 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 89da27fa4f..d8b89ff843 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 404cb22848..c0ffaafff6 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 789d383da7..01d92357dd 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 f30260ede4..957f71dacd 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 c1dccc49a1..578f17e436 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 094dc3c484..ffb31786af 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 24a9b33c08..4d4e5d504c 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 48efad9349..b52cafd04d 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 1c8aead6eb..436e8cedad 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 241f42dbb4..ac2ad6fc5f 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 11a33395f2..81a2585d62 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 84d418b612..843fb5055d 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 448d398a95..a8e2eead5f 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 f7459513d6..0e802d9dfd 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 18ce1d56e8..e88d476f13 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 32d658ab67..0601cf01fd 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 35f3e673db..c44b61d131 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 e741b794c1..4924ddcc1e 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 5e30ddb8d2..f0e43c1dee 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);