Add iscanonical.

TS 18661-1 adds an iscanonical classification macro to <math.h>.

The motivation for this is decimal floating-point, where some values
have both canonical and noncanonical encodings.  For IEEE binary
interchange formats, all encodings are canonical.  For x86/m68k
ldbl-96, and for ldbl-128ibm, there are encodings that do not
represent any valid value of the type; although formally iscanonical
does not need to handle trap representations (and so could just always
return 1), it seems useful, and in line with the description in the TS
of "representations that are extraneous to the floating-point model"
as being non-canonical (as well as "redundant representations of some
or all of its values"), for it to detect those representations and
return 0 for them.

This patch adds iscanonical to glibc.  It goes in a header
<bits/iscanonical.h>, included under appropriate conditions in
<math.h>.  The default header version just evaluates the argument
(converted to its semantic type, though current GCC will probably
discard that conversion and any exceptions resulting from it) and
returns 1.  ldbl-96 and ldbl-128ibm then have versions of the header
that call a function __iscanonicall for long double (the sizeof-based
tests will of course need updating for float128 support, like other
such type-generic macro implementations).  The ldbl-96 version of
__iscanonicall has appropriate conditionals to reflect the differences
in the m68k version of that format (where the high mantissa bit may be
either 0 or 1 when the exponent is 0 or 0x7fff).  Corresponding tests
for those formats are added as well.  Other architectures do not have
any new functions added because just returning 1 is correct for all
their floating-point formats.

Tested for x86_64, x86, mips64 (to test the default macro version) and
powerpc.

	* math/math.h [__GLIBC_USE (IEC_60559_BFP_EXT)]: Include
	<bits/iscanonical.h>.
	* bits/iscanonical.h: New file.
	* math/s_iscanonicall.c: Likewise.
	* math/Versions (__iscanonicall): New libm symbol at version
	GLIBC_2.25.
	* math/libm-test.inc (iscanonical_test_data): New array.
	(iscanonical_test): New function.
	(main): Call iscanonical_test.
	* math/Makefile (headers): Add bits/iscanonical.h.
	(type-ldouble-routines): Add s_iscanonicall.
	* manual/arith.texi (Floating Point Classes): Document
	iscanonical.
	* manual/libm-err-tab.pl: Update comment on interfaces without
	ulps tabulated.
	* sysdeps/ieee754/ldbl-128ibm/bits/iscanonical.h: New file.
	* sysdeps/ieee754/ldbl-128ibm/s_iscanonicall.c: Likewise.
	* sysdeps/ieee754/ldbl-128ibm/test-iscanonical-ldbl-128ibm.c:
	Likewise.
	* sysdeps/ieee754/ldbl-128ibm/Makefile (tests): Add
	test-iscanonical-ldbl-128ibm.
	* sysdeps/ieee754/ldbl-96/bits/iscanonical.h: New file.
	* sysdeps/ieee754/ldbl-96/s_iscanonicall.c: Likewise.
	* sysdeps/ieee754/ldbl-96/test-iscanonical-ldbl-96.c: Likewise.
	* sysdeps/ieee754/ldbl-96/Makefile: Likewise.
	* sysdeps/unix/sysv/linux/i386/libm.abilist: Update.
	* sysdeps/unix/sysv/linux/ia64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/m68k/m680x0/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/fpu/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/nofpu/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/libm-le.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/libm.abilist:
	Likewise.
	* sysdeps/unix/sysv/linux/x86_64/64/libm.abilist: Likewise.
	* sysdeps/unix/sysv/linux/x86_64/x32/libm.abilist: Likewise.
This commit is contained in:
Joseph Myers 2016-09-30 00:24:19 +00:00
parent 458d6339b7
commit 29cb929332
27 changed files with 643 additions and 8 deletions

View File

@ -1,3 +1,44 @@
2016-09-30 Joseph Myers <joseph@codesourcery.com>
* math/math.h [__GLIBC_USE (IEC_60559_BFP_EXT)]: Include
<bits/iscanonical.h>.
* bits/iscanonical.h: New file.
* math/s_iscanonicall.c: Likewise.
* math/Versions (__iscanonicall): New libm symbol at version
GLIBC_2.25.
* math/libm-test.inc (iscanonical_test_data): New array.
(iscanonical_test): New function.
(main): Call iscanonical_test.
* math/Makefile (headers): Add bits/iscanonical.h.
(type-ldouble-routines): Add s_iscanonicall.
* manual/arith.texi (Floating Point Classes): Document
iscanonical.
* manual/libm-err-tab.pl: Update comment on interfaces without
ulps tabulated.
* sysdeps/ieee754/ldbl-128ibm/bits/iscanonical.h: New file.
* sysdeps/ieee754/ldbl-128ibm/s_iscanonicall.c: Likewise.
* sysdeps/ieee754/ldbl-128ibm/test-iscanonical-ldbl-128ibm.c:
Likewise.
* sysdeps/ieee754/ldbl-128ibm/Makefile (tests): Add
test-iscanonical-ldbl-128ibm.
* sysdeps/ieee754/ldbl-96/bits/iscanonical.h: New file.
* sysdeps/ieee754/ldbl-96/s_iscanonicall.c: Likewise.
* sysdeps/ieee754/ldbl-96/test-iscanonical-ldbl-96.c: Likewise.
* sysdeps/ieee754/ldbl-96/Makefile: Likewise.
* sysdeps/unix/sysv/linux/i386/libm.abilist: Update.
* sysdeps/unix/sysv/linux/ia64/libm.abilist: Likewise.
* sysdeps/unix/sysv/linux/m68k/m680x0/libm.abilist: Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc32/fpu/libm.abilist:
Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc32/nofpu/libm.abilist:
Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc64/libm-le.abilist:
Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc64/libm.abilist:
Likewise.
* sysdeps/unix/sysv/linux/x86_64/64/libm.abilist: Likewise.
* sysdeps/unix/sysv/linux/x86_64/x32/libm.abilist: Likewise.
2016-09-29 Adhemerval Zanella <adhemerval.zanella@linaro.org>
* string/bits/string3.h: Remove C++ style comments.

2
NEWS
View File

@ -51,7 +51,7 @@ Version 2.25
* New <math.h> features are added from TS 18661-1:2014:
- Classification macros: issubnormal, iszero.
- Classification macros: iscanonical, issubnormal, iszero.
* The <sys/quota.h> header now includes the <linux/quota.h> header. Support
for the Linux quota interface which predates kernel version 2.4.22 has

28
bits/iscanonical.h Normal file
View File

@ -0,0 +1,28 @@
/* Define iscanonical macro.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#ifndef _MATH_H
# error "Never use <bits/iscanonical.h> directly; include <math.h> instead."
#endif
/* Return nonzero value if X is canonical. By default, we only have
IEEE interchange binary formats, in which all values are canonical,
but the argument must still be converted to its semantic type for
any exceptions arising from the conversion, before being
discarded. */
#define iscanonical(x) ((void) (__typeof (x)) (x), 1)

View File

@ -359,6 +359,23 @@ property at a time. Generally these macros execute faster than
@code{fpclassify}, since there is special hardware support for them.
You should therefore use the specific macros whenever possible.
@comment math.h
@comment ISO
@deftypefn {Macro} int iscanonical (@emph{float-type} @var{x})
@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
In some floating-point formats, some values have canonical (preferred)
and noncanonical encodings (for IEEE interchange binary formats, all
encodings are canonical). This macro returns a nonzero value if
@var{x} has a canonical encoding. It is from TS 18661-1:2014.
Note that some formats have multiple encodings of a value which are
all equally canonical; @code{iscanonical} returns a nonzero value for
all such encodings. Also, formats may have encodings that do not
correspond to any valid value of the type. In ISO C terms these are
@dfn{trap representations}; in @theglibc{}, @code{iscanonical} returns
zero for such encodings.
@end deftypefn
@comment math.h
@comment ISO
@deftypefn {Macro} int isfinite (@emph{float-type} @var{x})

View File

@ -77,7 +77,7 @@ use vars qw (%results @all_floats %suffices @all_functions);
"nextup", "pow", "remainder", "remquo", "rint", "round", "scalb",
"scalbn", "sin", "sincos", "sinh", "sqrt", "tan", "tanh", "tgamma",
"trunc", "y0", "y1", "yn" );
# fpclassify, isnormal, isfinite, isinf, isnan, issignaling,
# fpclassify, iscanonical, isnormal, isfinite, isinf, isnan, issignaling,
# issubnormal, iszero, signbit, isgreater, isgreaterequal, isless,
# islessequal, islessgreater, isunordered are not tabulated.

View File

@ -27,7 +27,7 @@ headers := math.h bits/mathcalls.h bits/mathinline.h bits/huge_val.h \
fpu_control.h complex.h bits/cmathcalls.h fenv.h \
bits/fenv.h bits/fenvinline.h bits/mathdef.h tgmath.h \
bits/math-finite.h bits/math-vector.h \
bits/libm-simd-decl-stubs.h
bits/libm-simd-decl-stubs.h bits/iscanonical.h
# FPU support code.
aux := setfpucw fpu_control
@ -94,7 +94,7 @@ types = $(type-ldouble-$(long-double-fcts)) double float
# long double support
type-ldouble-suffix := l
type-ldouble-routines := t_sincosl k_sincosl
type-ldouble-routines := t_sincosl k_sincosl s_iscanonicall
type-ldouble-yes := ldouble
# double support

View File

@ -216,5 +216,6 @@ libm {
}
GLIBC_2.25 {
fesetexcept; fetestexceptflag; fegetmode; fesetmode;
__iscanonicall;
}
}

View File

@ -46,9 +46,9 @@
cbrt, ceil, copysign, cos, cosh, drem, erf, erfc, exp, exp10, exp2, expm1,
fabs, fdim, finite, floor, fma, fmax, fmin, fmod, fpclassify,
frexp, gamma, hypot,
ilogb, isfinite, isinf, isnan, isnormal, issignaling, issubnormal, iszero,
isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
j0, j1, jn,
ilogb, iscanonical, isfinite, isinf, isnan, isnormal, issignaling,
issubnormal, iszero, isless, islessequal, isgreater,
isgreaterequal, islessgreater, isunordered, j0, j1, jn,
ldexp, lgamma, log, log10, log1p, log2, logb,
modf, nearbyint, nextafter, nexttoward,
pow, pow10, remainder, remquo, rint, lrint, llrint,
@ -8160,6 +8160,31 @@ ilogb_test (void)
ALL_RM_TEST (ilogb, 1, ilogb_test_data, RUN_TEST_LOOP_f_i, END);
}
static const struct test_f_i_data iscanonical_test_data[] =
{
TEST_f_b (iscanonical, 0, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, minus_zero, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, 10, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, min_subnorm_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, -min_subnorm_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, min_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, -min_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, max_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, -max_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, plus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, minus_infty, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, -qnan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
TEST_f_b (iscanonical, -snan_value, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
};
static void
iscanonical_test (void)
{
ALL_RM_TEST (iscanonical, 1, iscanonical_test_data, RUN_TEST_LOOP_f_b_tg, END);
}
static const struct test_f_i_data isfinite_test_data[] =
{
TEST_f_b (isfinite, 0, 1, NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED),
@ -12713,6 +12738,7 @@ main (int argc, char **argv)
/* Classification macros: */
finite_test ();
fpclassify_test ();
iscanonical_test ();
isfinite_test ();
isinf_test ();
isnan_test ();

View File

@ -317,6 +317,8 @@ enum
#endif /* Use ISO C99. */
#if __GLIBC_USE (IEC_60559_BFP_EXT)
# include <bits/iscanonical.h>
/* Return nonzero value if X is a signaling NaN. */
# ifdef __NO_LONG_DOUBLE_MATH
# define issignaling(x) \

1
math/s_iscanonicall.c Normal file
View File

@ -0,0 +1 @@
/* Not needed by default. */

View File

@ -11,5 +11,5 @@ endif
ifeq ($(subdir),math)
tests += test-fmodl-ldbl-128ibm test-remainderl-ldbl-128ibm \
test-remquol-ldbl-128ibm
test-remquol-ldbl-128ibm test-iscanonical-ldbl-128ibm
endif

View File

@ -0,0 +1,35 @@
/* Define iscanonical macro. ldbl-128ibm version.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#ifndef _MATH_H
# error "Never use <bits/iscanonical.h> directly; include <math.h> instead."
#endif
extern int __iscanonicall (long double __x)
__THROW __attribute__ ((__const__));
/* Return nonzero value if X is canonical. In IEEE interchange binary
formats, all values are canonical, but the argument must still be
converted to its semantic type for any exceptions arising from the
conversion, before being discarded; in IBM long double, there are
encodings that are not consistently handled as corresponding to any
particular value of the type, and we return 0 for those. */
#define iscanonical(x) \
(sizeof (x) == sizeof (long double) \
? __iscanonicall (x) \
: ((void) (__typeof (x)) (x), 1))

View File

@ -0,0 +1,59 @@
/* Test whether long double value is canonical. ldbl-128ibm version.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <math.h>
#include <math_private.h>
#include <stdint.h>
int
__iscanonicall (long double x)
{
double xhi, xlo;
uint64_t hx, lx;
ldbl_unpack (x, &xhi, &xlo);
EXTRACT_WORDS64 (hx, xhi);
EXTRACT_WORDS64 (lx, xlo);
int64_t ix = hx & 0x7fffffffffffffffULL;
int64_t iy = lx & 0x7fffffffffffffffULL;
int hexp = (ix & 0x7ff0000000000000LL) >> 52;
int lexp = (iy & 0x7ff0000000000000LL) >> 52;
if (iy == 0)
/* Low part 0 is always OK. */
return 1;
if (hexp == 0x7ff)
/* If a NaN, the low part does not matter. If an infinity, the
low part must be 0, in which case we have already returned. */
return ix != 0x7ff0000000000000LL;
/* The high part is finite and the low part is nonzero. There must
be sufficient difference between the exponents. */
bool low_p2;
if (lexp == 0)
{
/* Adjust the exponent for subnormal low part. */
lexp = 12 - __builtin_clzll (iy);
low_p2 = iy == (1LL << (51 + lexp));
}
else
low_p2 = (iy & 0xfffffffffffffLL) == 0;
int expdiff = hexp - lexp;
return expdiff > 53 || (expdiff == 53 && low_p2 && (ix & 1) == 0);
}

View File

@ -0,0 +1,203 @@
/* Test iscanonical for ldbl-128ibm.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <float.h>
#include <math.h>
#include <math_private.h>
#include <stdbool.h>
#include <stdio.h>
struct test
{
double hi, lo;
bool canonical;
};
static const struct test tests[] =
{
{ __builtin_nan (""), 0.0, true },
{ __builtin_nan (""), DBL_MAX, true },
{ __builtin_nan (""), __builtin_inf (), true },
{ __builtin_nan (""), __builtin_nan (""), true },
{ __builtin_nan (""), __builtin_nans (""), true },
{ __builtin_nans (""), 0.0, true },
{ __builtin_nans (""), DBL_MAX, true },
{ __builtin_nans (""), __builtin_inf (), true },
{ __builtin_nans (""), __builtin_nan (""), true },
{ __builtin_nans (""), __builtin_nans (""), true },
{ __builtin_inf (), 0.0, true },
{ __builtin_inf (), -0.0, true },
{ -__builtin_inf (), 0.0, true },
{ -__builtin_inf (), -0.0, true },
{ __builtin_inf (), DBL_TRUE_MIN, false },
{ __builtin_inf (), -DBL_TRUE_MIN, false },
{ -__builtin_inf (), DBL_TRUE_MIN, false },
{ -__builtin_inf (), -DBL_TRUE_MIN, false },
{ __builtin_inf (), DBL_MIN, false },
{ __builtin_inf (), -DBL_MIN, false },
{ -__builtin_inf (), DBL_MIN, false },
{ -__builtin_inf (), -DBL_MIN, false },
{ __builtin_inf (), __builtin_inf (), false },
{ __builtin_inf (), -__builtin_inf (), false },
{ -__builtin_inf (), __builtin_inf (), false },
{ -__builtin_inf (), -__builtin_inf (), false },
{ __builtin_inf (), __builtin_nan (""), false },
{ __builtin_inf (), -__builtin_nan (""), false },
{ -__builtin_inf (), __builtin_nan (""), false },
{ -__builtin_inf (), -__builtin_nan (""), false },
{ 0.0, 0.0, true },
{ 0.0, -0.0, true },
{ -0.0, 0.0, true },
{ -0.0, -0.0, true },
{ 0.0, DBL_TRUE_MIN, false },
{ 0.0, -DBL_TRUE_MIN, false },
{ -0.0, DBL_TRUE_MIN, false },
{ -0.0, -DBL_TRUE_MIN, false },
{ 0.0, DBL_MAX, false },
{ 0.0, -DBL_MAX, false },
{ -0.0, DBL_MAX, false },
{ -0.0, -DBL_MAX, false },
{ 0.0, __builtin_inf (), false },
{ 0.0, -__builtin_inf (), false },
{ -0.0, __builtin_inf (), false },
{ -0.0, -__builtin_inf (), false },
{ 0.0, __builtin_nan (""), false },
{ 0.0, -__builtin_nan (""), false },
{ -0.0, __builtin_nan (""), false },
{ -0.0, -__builtin_nan (""), false },
{ 1.0, 0.0, true },
{ 1.0, -0.0, true },
{ -1.0, 0.0, true },
{ -1.0, -0.0, true },
{ 1.0, DBL_TRUE_MIN, true },
{ 1.0, -DBL_TRUE_MIN, true },
{ -1.0, DBL_TRUE_MIN, true },
{ -1.0, -DBL_TRUE_MIN, true },
{ 1.0, DBL_MAX, false },
{ 1.0, -DBL_MAX, false },
{ -1.0, DBL_MAX, false },
{ -1.0, -DBL_MAX, false },
{ 1.0, __builtin_inf (), false },
{ 1.0, -__builtin_inf (), false },
{ -1.0, __builtin_inf (), false },
{ -1.0, -__builtin_inf (), false },
{ 1.0, __builtin_nan (""), false },
{ 1.0, -__builtin_nan (""), false },
{ -1.0, __builtin_nan (""), false },
{ -1.0, -__builtin_nan (""), false },
{ 0x1p1023, 0x1.1p969, true },
{ 0x1p1023, -0x1.1p969, true },
{ -0x1p1023, 0x1.1p969, true },
{ -0x1p1023, -0x1.1p969, true },
{ 0x1p1023, 0x1.1p970, false },
{ 0x1p1023, -0x1.1p970, false },
{ -0x1p1023, 0x1.1p970, false },
{ -0x1p1023, -0x1.1p970, false },
{ 0x1p1023, 0x1p970, true },
{ 0x1p1023, -0x1p970, true },
{ -0x1p1023, 0x1p970, true },
{ -0x1p1023, -0x1p970, true },
{ 0x1.0000000000001p1023, 0x1p970, false },
{ 0x1.0000000000001p1023, -0x1p970, false },
{ -0x1.0000000000001p1023, 0x1p970, false },
{ -0x1.0000000000001p1023, -0x1p970, false },
{ 0x1p-969, 0x1.1p-1023, true },
{ 0x1p-969, -0x1.1p-1023, true },
{ -0x1p-969, 0x1.1p-1023, true },
{ -0x1p-969, -0x1.1p-1023, true },
{ 0x1p-969, 0x1.1p-1022, false },
{ 0x1p-969, -0x1.1p-1022, false },
{ -0x1p-969, 0x1.1p-1022, false },
{ -0x1p-969, -0x1.1p-1022, false },
{ 0x1p-969, 0x1p-1022, true },
{ 0x1p-969, -0x1p-1022, true },
{ -0x1p-969, 0x1p-1022, true },
{ -0x1p-969, -0x1p-1022, true },
{ 0x1.0000000000001p-969, 0x1p-1022, false },
{ 0x1.0000000000001p-969, -0x1p-1022, false },
{ -0x1.0000000000001p-969, 0x1p-1022, false },
{ -0x1.0000000000001p-969, -0x1p-1022, false },
{ 0x1p-970, 0x1.1p-1024, true },
{ 0x1p-970, -0x1.1p-1024, true },
{ -0x1p-970, 0x1.1p-1024, true },
{ -0x1p-970, -0x1.1p-1024, true },
{ 0x1p-970, 0x1.1p-1023, false },
{ 0x1p-970, -0x1.1p-1023, false },
{ -0x1p-970, 0x1.1p-1023, false },
{ -0x1p-970, -0x1.1p-1023, false },
{ 0x1p-970, 0x1p-1023, true },
{ 0x1p-970, -0x1p-1023, true },
{ -0x1p-970, 0x1p-1023, true },
{ -0x1p-970, -0x1p-1023, true },
{ 0x1.0000000000001p-970, 0x1p-1023, false },
{ 0x1.0000000000001p-970, -0x1p-1023, false },
{ -0x1.0000000000001p-970, 0x1p-1023, false },
{ -0x1.0000000000001p-970, -0x1p-1023, false },
{ 0x1p-1000, 0x1.1p-1054, true },
{ 0x1p-1000, -0x1.1p-1054, true },
{ -0x1p-1000, 0x1.1p-1054, true },
{ -0x1p-1000, -0x1.1p-1054, true },
{ 0x1p-1000, 0x1.1p-1053, false },
{ 0x1p-1000, -0x1.1p-1053, false },
{ -0x1p-1000, 0x1.1p-1053, false },
{ -0x1p-1000, -0x1.1p-1053, false },
{ 0x1p-1000, 0x1p-1053, true },
{ 0x1p-1000, -0x1p-1053, true },
{ -0x1p-1000, 0x1p-1053, true },
{ -0x1p-1000, -0x1p-1053, true },
{ 0x1.0000000000001p-1000, 0x1p-1053, false },
{ 0x1.0000000000001p-1000, -0x1p-1053, false },
{ -0x1.0000000000001p-1000, 0x1p-1053, false },
{ -0x1.0000000000001p-1000, -0x1p-1053, false },
{ 0x1p-1021, 0x1p-1074, true },
{ 0x1p-1021, -0x1p-1074, true },
{ -0x1p-1021, 0x1p-1074, true },
{ -0x1p-1021, -0x1p-1074, true },
{ 0x1.0000000000001p-1021, 0x1p-1074, false },
{ 0x1.0000000000001p-1021, -0x1p-1074, false },
{ -0x1.0000000000001p-1021, 0x1p-1074, false },
{ -0x1.0000000000001p-1021, -0x1p-1074, false },
{ 0x1p-1022, 0x1p-1074, false },
{ 0x1p-1022, -0x1p-1074, false },
{ -0x1p-1022, 0x1p-1074, false },
{ -0x1p-1022, -0x1p-1074, false },
};
static int
do_test (void)
{
int result = 0;
for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++)
{
long double ld = ldbl_pack (tests[i].hi, tests[i].lo);
bool canonical = iscanonical (ld);
if (canonical == tests[i].canonical)
printf ("PASS: test %zu\n", i);
else
{
printf ("FAIL: test %zu\n", i);
result = 1;
}
}
return result;
}
#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"

View File

@ -0,0 +1,21 @@
# Makefile for sysdeps/ieee754/ldbl-96.
# Copyright (C) 2016 Free Software Foundation, Inc.
# This file is part of the GNU C Library.
# The GNU C Library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# The GNU C Library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public
# License along with the GNU C Library; if not, see
# <http://www.gnu.org/licenses/>.
ifeq ($(subdir),math)
tests += test-iscanonical-ldbl-96
endif

View File

@ -0,0 +1,35 @@
/* Define iscanonical macro. ldbl-96 version.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#ifndef _MATH_H
# error "Never use <bits/iscanonical.h> directly; include <math.h> instead."
#endif
extern int __iscanonicall (long double __x)
__THROW __attribute__ ((__const__));
/* Return nonzero value if X is canonical. In IEEE interchange binary
formats, all values are canonical, but the argument must still be
converted to its semantic type for any exceptions arising from the
conversion, before being discarded; in extended precision, there
are encodings that are not consistently handled as corresponding to
any particular value of the type, and we return 0 for those. */
#define iscanonical(x) \
(sizeof (x) == sizeof (long double) \
? __iscanonicall (x) \
: ((void) (__typeof (x)) (x), 1))

View File

@ -0,0 +1,43 @@
/* Test whether long double value is canonical. ldbl-96 version.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <float.h>
#include <math.h>
#include <math_private.h>
#include <stdbool.h>
#include <stdint.h>
int
__iscanonicall (long double x)
{
uint32_t se, i0, i1 __attribute__ ((unused));
GET_LDOUBLE_WORDS (se, i0, i1, x);
int32_t ix = se & 0x7fff;
bool mant_high = (i0 & 0x80000000) != 0;
if (LDBL_MIN_EXP == -16381)
/* Intel variant: the high mantissa bit should have a value
determined by the exponent. */
return ix > 0 ? mant_high : !mant_high;
else
/* M68K variant: both values of the high bit are valid for the
greatest and smallest exponents, while other exponents require
the high bit to be set. */
return ix == 0 || ix == 0x7fff || mant_high;
}

View File

@ -0,0 +1,114 @@
/* Test iscanonical for ldbl-96.
Copyright (C) 2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <float.h>
#include <math.h>
#include <math_private.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
struct test
{
bool sign;
uint16_t exponent;
bool high;
uint64_t mantissa;
bool canonical;
};
#define M68K_VARIANT (LDBL_MIN_EXP == -16382)
static const struct test tests[] =
{
{ false, 0, true, 0, M68K_VARIANT },
{ true, 0, true, 0, M68K_VARIANT },
{ false, 0, true, 1, M68K_VARIANT },
{ true, 0, true, 1, M68K_VARIANT },
{ false, 0, true, 0x100000000ULL, M68K_VARIANT },
{ true, 0, true, 0x100000000ULL, M68K_VARIANT },
{ false, 0, false, 0, true },
{ true, 0, false, 0, true },
{ false, 0, false, 1, true },
{ true, 0, false, 1, true },
{ false, 0, false, 0x100000000ULL, true },
{ true, 0, false, 0x100000000ULL, true },
{ false, 1, true, 0, true },
{ true, 1, true, 0, true },
{ false, 1, true, 1, true },
{ true, 1, true, 1, true },
{ false, 1, true, 0x100000000ULL, true },
{ true, 1, true, 0x100000000ULL, true },
{ false, 1, false, 0, false },
{ true, 1, false, 0, false },
{ false, 1, false, 1, false },
{ true, 1, false, 1, false },
{ false, 1, false, 0x100000000ULL, false },
{ true, 1, false, 0x100000000ULL, false },
{ false, 0x7ffe, true, 0, true },
{ true, 0x7ffe, true, 0, true },
{ false, 0x7ffe, true, 1, true },
{ true, 0x7ffe, true, 1, true },
{ false, 0x7ffe, true, 0x100000000ULL, true },
{ true, 0x7ffe, true, 0x100000000ULL, true },
{ false, 0x7ffe, false, 0, false },
{ true, 0x7ffe, false, 0, false },
{ false, 0x7ffe, false, 1, false },
{ true, 0x7ffe, false, 1, false },
{ false, 0x7ffe, false, 0x100000000ULL, false },
{ true, 0x7ffe, false, 0x100000000ULL, false },
{ false, 0x7fff, true, 0, true },
{ true, 0x7fff, true, 0, true },
{ false, 0x7fff, true, 1, true },
{ true, 0x7fff, true, 1, true },
{ false, 0x7fff, true, 0x100000000ULL, true },
{ true, 0x7fff, true, 0x100000000ULL, true },
{ false, 0x7fff, false, 0, M68K_VARIANT },
{ true, 0x7fff, false, 0, M68K_VARIANT },
{ false, 0x7fff, false, 1, M68K_VARIANT },
{ true, 0x7fff, false, 1, M68K_VARIANT },
{ false, 0x7fff, false, 0x100000000ULL, M68K_VARIANT },
{ true, 0x7fff, false, 0x100000000ULL, M68K_VARIANT },
};
static int
do_test (void)
{
int result = 0;
for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++)
{
long double ld;
SET_LDOUBLE_WORDS (ld, tests[i].exponent | (tests[i].sign << 15),
(tests[i].mantissa >> 32) | (tests[i].high << 31),
tests[i].mantissa & 0xffffffffULL);
bool canonical = iscanonical (ld);
if (canonical == tests[i].canonical)
printf ("PASS: test %zu\n", i);
else
{
printf ("FAIL: test %zu\n", i);
result = 1;
}
}
return result;
}
#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"

View File

@ -423,6 +423,7 @@ GLIBC_2.24 nextup F
GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -352,6 +352,7 @@ GLIBC_2.24 nextup F
GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -421,6 +421,7 @@ GLIBC_2.24 nextup F
GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -423,6 +423,7 @@ GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __fe_dfl_mode D 0x8
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -422,6 +422,7 @@ GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __fe_dfl_mode D 0x8
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -417,6 +417,7 @@ GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __fe_dfl_mode D 0x8
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -98,6 +98,7 @@ GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __fe_dfl_mode D 0x8
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -412,6 +412,7 @@ GLIBC_2.24 nextup F
GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F

View File

@ -411,6 +411,7 @@ GLIBC_2.24 nextup F
GLIBC_2.24 nextupf F
GLIBC_2.24 nextupl F
GLIBC_2.25 GLIBC_2.25 A
GLIBC_2.25 __iscanonicall F
GLIBC_2.25 fegetmode F
GLIBC_2.25 fesetexcept F
GLIBC_2.25 fesetmode F