mirror/glibc
2
0
Fork 0
mirror of git://sourceware.org/git/glibc.git synced 2025-01-18 12:16:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix ldbl-128ibm truncl for non-default rounding modes (bug 19593).

Browse Source 
The ldbl-128ibm implementation of truncl is only correct in
round-to-nearest mode (in other modes, there are incorrect results and
overflow exceptions in some cases).  It is also unnecessarily
complicated, rounding both high and low parts to the nearest integer
and then adjusting for the semantics of trunc, when it seems more
natural to take the truncation of the high part (__trunc optimized
inline versions can be used), and the floor or ceiling of the low part
(depending on the sign of the high part) if the high part is an
integer, as was done for floorl and ceill.  This patch makes it use
that simpler approach.

Tested for powerpc.

	[BZ #19593]
	* sysdeps/ieee754/ldbl-128ibm/s_truncl.c (__truncl): Use __trunc
	on high part and __floor or __ceil on low part then use
	ldbl_canonicalize_int if needed.
This commit is contained in:
Joseph Myers 2016-02-18 21:52:07 +00:00
parent 8a9fa0086d
commit e2310a27be
2 changed files with 16 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,5 +1,10 @@
2016-02-18 Joseph Myers <joseph@codesourcery.com>
[BZ #19593]
* sysdeps/ieee754/ldbl-128ibm/s_truncl.c (__truncl): Use __trunc
on high part and __floor or __ceil on low part then use
ldbl_canonicalize_int if needed.
[BZ #19592]
* sysdeps/ieee754/ldbl-128ibm/s_ceill.c (__ceill): Use __ceil on
high and low parts then use ldbl_canonicalize_int if needed.

50
sysdeps/ieee754/ldbl-128ibm/s_truncl.c
View File

@ -35,50 +35,22 @@ __truncl (long double x)
&& __builtin_isless (__builtin_fabs (xh),
__builtin_inf ()), 1))
{
double orig_xh;
/* Long double arithmetic, including the canonicalisation below,
only works in round-to-nearest mode. */
/* Convert the high double to integer. */
orig_xh = xh;
hi = ldbl_nearbyint (xh);
/* Subtract integral high part from the value. */
xh -= hi;
ldbl_canonicalize (&xh, &xl);
/* Now convert the low double, adjusted for any remainder from the
high double. */
lo = ldbl_nearbyint (xh);
/* Adjust the result when the remainder is non-zero. nearbyint
rounds values to the nearest integer, and values halfway
between integers to the nearest even integer. floorl must
round towards -Inf. */
xh -= lo;
ldbl_canonicalize (&xh, &xl);
if (orig_xh < 0.0)
hi = __trunc (xh);
if (hi != xh)
{
if (xh > 0.0 || (xh == 0.0 && xl > 0.0))
lo += 1.0;
/* The high part is not an integer; the low part does not
affect the result. */
xh = hi;
xl = 0;
}
else
{
if (xh < 0.0 || (xh == 0.0 && xl < 0.0))
lo -= 1.0;
/* The high part is a nonzero integer. */
lo = xh > 0 ? __floor (xl) : __ceil (xl);
xh = hi;
xl = lo;
ldbl_canonicalize_int (&xh, &xl);
}
/* Ensure the final value is canonical. In certain cases,
rounding causes hi,lo calculated so far to be non-canonical. */
xh = hi;
xl = lo;
ldbl_canonicalize (&xh, &xl);
/* Ensure we return -0 rather than +0 when appropriate. */
if (orig_xh < 0.0)
xh = -__builtin_fabs (xh);
}
return ldbl_pack (xh, xl);