lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-11-14 04:22:38 +03:00
Code Activity

Change fromfp functions to return floating types following C23 (bug 28327)

Browse Source 
As discussed in bug 28327, C23 changed the fromfp functions to return
floating types instead of intmax_t / uintmax_t.  (Although the
motivation in N2548 was reducing the use of intmax_t in library
interfaces, the new version does have the advantage of being able to
specify arbitrary integer widths for e.g. assigning the result to a
_BitInt, as well as being able to indicate an error case in-band with
a NaN return.)

As with other such changes from interfaces introduced in TS 18661,
implement the new types as a replacement for the old ones, with the
old functions remaining as compat symbols but not supported as an API.
The test generator used for many of the tests is updated to handle
both versions of the functions.

Tested for x86_64 and x86, and with build-many-glibcs.py.

Also tested tgmath tests for x86_64 with GCC 7 to make sure that the
modified case for older compilers in <tgmath.h> does work.

Also tested for powerpc64le to cover the ldbl-128ibm implementation
and the other things that are handled differently for that
configuration.  The new tests fail for ibm128, but all the failures
relate to incorrect signs of zero results and turn out to arise from
bugs in the underlying roundl, ceill, truncl and floorl
implementations that I've reported in bug 33623, rather than
indicating any bug in the actual new implementation of the functions
for that format.  So given fixes for those functions (which shouldn't
be hard, and of course should add to the tests for those functions
rather than relying only on indirect testing via fromfp), the fromfp
tests should start passing for ibm128 as well.
This commit is contained in:
Joseph Myers
2025-11-13 00:04:21 +00:00
parent 989e538224
commit 1f79bc4838
122 changed files with 42884 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
NEWS
View File

@@ -35,6 +35,13 @@ Deprecated and removed features, and other changes affecting compatibility:
to the name of that function in ISO C2Y. The old function continues
to exist as a compatibility symbol for old binaries.
* The fromfp, fromfpx, ufromfp and ufromfpx functions, and the
corresponding functions for other floating-point types, now return
their result in the same type as their floating-point argument, rather
than intmax_t or uintmax_t, in accordance with a change to the
definition of these functions in ISO C23. Existing binaries that use
the versions returning intmax_t or uintmax_t will continue to work.
Changes to build and runtime requirements:
[Add changes to build and runtime requirements here]

65
manual/arith.texi
View File

@@ -1608,26 +1608,26 @@ These functions are just like @code{round}, but they return a
@code{long long int} instead of a floating-point number.
@end deftypefun
@deftypefun intmax_t fromfp (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfp (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpx (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpxf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpxl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpxfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx intmax_t fromfpxfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpx (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpxf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpxl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpxfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx uintmax_t ufromfpxfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefun double fromfp (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx float fromfpf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx {long double} fromfpl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatN fromfpfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatNx fromfpfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx double ufromfp (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx float ufromfpf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx {long double} ufromfpl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatN ufromfpfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatNx ufromfpfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx double fromfpx (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx float fromfpxf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx {long double} fromfpxl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatN fromfpxfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatNx fromfpxfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx double ufromfpx (double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx float ufromfpxf (float @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx {long double} ufromfpxl (long double @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatN ufromfpxfN (_Float@var{N} @var{x}, int @var{round}, unsigned int @var{width})
@deftypefunx _FloatNx ufromfpxfNx (_Float@var{N}x @var{x}, int @var{round}, unsigned int @var{width})
@standards{ISO, math.h}
@standardsx{fromfpfN, TS 18661-3:2015, math.h}
@standardsx{fromfpfNx, TS 18661-3:2015, math.h}
@@ -1638,17 +1638,22 @@ These functions are just like @code{round}, but they return a
@standardsx{ufromfpxfN, TS 18661-3:2015, math.h}
@standardsx{ufromfpxfNx, TS 18661-3:2015, math.h}
@safety{@prelim{}@mtsafe{}@assafe{}@acsafe{}}
These functions, from TS 18661-1:2014 and TS 18661-3:2015, convert a
floating-point number to an integer according to the rounding direction
@var{round} (one of the @code{FP_INT_*} macros). If the integer is
outside the range of a signed or unsigned (depending on the return type
of the function) type of width @var{width} bits (or outside the range of
the return type, if @var{width} is larger), or if @var{x} is infinite or
NaN, or if @var{width} is zero, a domain error occurs and an unspecified
value is returned. The functions with an @samp{x} in their names raise
the inexact exception when a domain error does not occur and the
argument is not an integer; the other functions do not raise the inexact
exception.
floating-point number to an integer according to the rounding
direction @var{round} (one of the @code{FP_INT_*} macros). If the
integer is outside the range of a two's complement signed or unsigned
(depending on the return type of the function) integer of width
@var{width} bits, or if @var{x} is infinite or NaN, or if @var{width}
is zero, a domain error occurs and a NaN is returned. The functions
with an @samp{x} in their names raise the inexact exception when a
domain error does not occur and the argument is not an integer; the
other functions do not raise the inexact exception.
Following ISO C23, in @theglibc{} these functions return their result
in the floating-point argument type. In TS 18661-1:2014 and TS
18661-3:2015, they were originally defined to return @code{intmax_t}
and @code{uintmax_t}.
@end deftypefun

52
math/Makefile
View File

@@ -221,6 +221,8 @@ libm-calls = \
s_floorF \
s_fmaF \
s_fpclassifyF \
s_fromfpF \
s_fromfpxF \
s_getpayloadF \
s_issignalingF \
s_llrintF \
@@ -247,6 +249,8 @@ libm-calls = \
s_totalorderF \
s_totalordermagF \
s_truncF \
s_ufromfpF \
s_ufromfpxF \
x2y2m1F \
# libm-calls
@@ -719,10 +723,6 @@ libm-test-funcs-noauto-base = \
canonicalize \
ceil \
cimag \
compat_fromfp \
compat_fromfpx \
compat_ufromfp \
compat_ufromfpx \
conj \
copysign \
cproj \
@@ -745,6 +745,8 @@ libm-test-funcs-noauto-base = \
fmod \
fpclassify \
frexp \
fromfp \
fromfpx \
getpayload \
ilogb \
iscanonical \
@@ -789,15 +791,25 @@ libm-test-funcs-noauto-base = \
totalorder \
totalordermag \
trunc \
ufromfp \
ufromfpx \
# libm-test-funcs-noauto-base
libm-test-funcs-noauto = \
$(libm-test-funcs-noauto-base) \
compat_fromfp \
compat_fromfpx \
compat_totalorder \
compat_totalordermag \
compat_ufromfp \
compat_ufromfpx \
# libm-test-funcs-noauto
libm-test-funcs-compat = \
compat_fromfp \
compat_fromfpx \
compat_totalorder \
compat_totalordermag \
compat_ufromfp \
compat_ufromfpx \
# libm-test-funcs-compat
libm-test-funcs-narrow = \
add \
@@ -1459,6 +1471,8 @@ CFLAGS-s_fmul.c += -fno-builtin-fmull
CFLAGS-s_frexp.c += -fno-builtin-frexpl
CFLAGS-s_compat_fromfp.c += -fno-builtin-fromfpl
CFLAGS-s_compat_fromfpx.c += -fno-builtin-fromfpxl
CFLAGS-s_fromfp.c += -fno-builtin-fromfpl
CFLAGS-s_fromfpx.c += -fno-builtin-fromfpxl
CFLAGS-s_fsqrt.c += -fno-builtin-fsqrtl
CFLAGS-s_fsub.c += -fno-builtin-fsubl
CFLAGS-s_getpayload.c += -fno-builtin-getpayloadl
@@ -1522,6 +1536,8 @@ CFLAGS-s_totalordermag.c += -fno-builtin-totalordermagl
CFLAGS-s_trunc.c += -fno-builtin-truncl
CFLAGS-s_compat_ufromfp.c += -fno-builtin-ufromfpl
CFLAGS-s_compat_ufromfpx.c += -fno-builtin-ufromfpxl
CFLAGS-s_ufromfp.c += -fno-builtin-ufromfpl
CFLAGS-s_ufromfpx.c += -fno-builtin-ufromfpxl
CFLAGS-s_y0.c += -fno-builtin-y0l
CFLAGS-s_y1.c += -fno-builtin-y1l
CFLAGS-s_yn.c += -fno-builtin-ynl
@@ -1602,6 +1618,8 @@ CFLAGS-s_fmul.c += -fno-builtin-f32mulf32x -fno-builtin-f32mulf64
CFLAGS-s_frexp.c += -fno-builtin-frexpf32x -fno-builtin-frexpf64
CFLAGS-s_compat_fromfp.c += -fno-builtin-fromfpf32x -fno-builtin-fromfpf64
CFLAGS-s_compat_fromfpx.c += -fno-builtin-fromfpxf32x -fno-builtin-fromfpxf64
CFLAGS-s_fromfp.c += -fno-builtin-fromfpf32x -fno-builtin-fromfpf64
CFLAGS-s_fromfpx.c += -fno-builtin-fromfpxf32x -fno-builtin-fromfpxf64
CFLAGS-s_fsqrt.c += -fno-builtin-f32sqrtf32x -fno-builtin-f32sqrtf64
CFLAGS-s_fsub.c += -fno-builtin-f32subf32x -fno-builtin-f32subf64
CFLAGS-s_getpayload.c += -fno-builtin-getpayloadf32x -fno-builtin-getpayloadf64
@@ -1659,6 +1677,8 @@ CFLAGS-s_totalordermag.c += -fno-builtin-totalordermagf32x -fno-builtin-totalord
CFLAGS-s_trunc.c += -fno-builtin-truncf32x -fno-builtin-truncf64
CFLAGS-s_compat_ufromfp.c += -fno-builtin-ufromfpf32x -fno-builtin-ufromfpf64
CFLAGS-s_compat_ufromfpx.c += -fno-builtin-ufromfpxf32x -fno-builtin-ufromfpxf64
CFLAGS-s_ufromfp.c += -fno-builtin-ufromfpf32x -fno-builtin-ufromfpf64
CFLAGS-s_ufromfpx.c += -fno-builtin-ufromfpxf32x -fno-builtin-ufromfpxf64
CFLAGS-s_y0.c += -fno-builtin-y0f32x -fno-builtin-y0f64
CFLAGS-s_y1.c += -fno-builtin-y1f32x -fno-builtin-y1f64
CFLAGS-s_yn.c += -fno-builtin-ynf32x -fno-builtin-ynf64
@@ -1734,6 +1754,8 @@ CFLAGS-w_fmodf.c += -fno-builtin-fmodf32
CFLAGS-s_frexpf.c += -fno-builtin-frexpf32
CFLAGS-s_compat_fromfpf.c += -fno-builtin-fromfpf32
CFLAGS-s_compat_fromfpxf.c += -fno-builtin-fromfpxf32
CFLAGS-s_fromfpf.c += -fno-builtin-fromfpf32
CFLAGS-s_fromfpxf.c += -fno-builtin-fromfpxf32
CFLAGS-s_getpayloadf.c += -fno-builtin-getpayloadf32
CFLAGS-w_hypotf.c += -fno-builtin-hypotf32
CFLAGS-w_ilogbf.c += -fno-builtin-ilogbf32
@@ -1789,6 +1811,8 @@ CFLAGS-s_totalordermagf.c += -fno-builtin-totalordermagf32
CFLAGS-s_truncf.c += -fno-builtin-truncf32
CFLAGS-s_compat_ufromfpf.c += -fno-builtin-ufromfpf32
CFLAGS-s_compat_ufromfpxf.c += -fno-builtin-ufromfpxf32
CFLAGS-s_ufromfpf.c += -fno-builtin-ufromfpf32
CFLAGS-s_ufromfpxf.c += -fno-builtin-ufromfpxf32
CFLAGS-s_y0f.c += -fno-builtin-y0f32
CFLAGS-s_y1f.c += -fno-builtin-y1f32
CFLAGS-s_ynf.c += -fno-builtin-ynf32
@@ -1800,6 +1824,26 @@ CFLAGS-s_modff.c += $(config-cflags-signaling-nans)
CFLAGS-s_modfl.c += $(config-cflags-signaling-nans)
CFLAGS-s_modff128.c += $(config-cflags-signaling-nans)
# These files rely on C23 semantics for avoiding "inexact" exceptions
# from rounding functions. These settings can be removed when glibc
# builds with -std=gnu23 or later.
CFLAGS-s_fromfp.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpx.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfp.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpx.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpf.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpxf.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpf.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpxf.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpl.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpxl.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpl.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpxl.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpf128.c += -fno-fp-int-builtin-inexact
CFLAGS-s_fromfpxf128.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpf128.c += -fno-fp-int-builtin-inexact
CFLAGS-s_ufromfpxf128.c += -fno-fp-int-builtin-inexact
$(addprefix $(objpfx),\
$(filter-out $(tests-static) $(libm-tests-vector),\
$(tests) $(tests-internal))): $(libm)

9
math/Versions
View File

@@ -708,5 +708,14 @@ libm {
y1f;
ynf;
tgammaf;
# fromfp changed to return a floating type.
fromfp; fromfpf; fromfpl;
fromfpf32; fromfpf64; fromfpf32x; fromfpf64x; fromfpf128;
fromfpx; fromfpxf; fromfpxl;
fromfpxf32; fromfpxf64; fromfpxf32x; fromfpxf64x; fromfpxf128;
ufromfp; ufromfpf; ufromfpl;
ufromfpf32; ufromfpf64; ufromfpf32x; ufromfpf64x; ufromfpf128;
ufromfpx; ufromfpxf; ufromfpxl;
ufromfpxf32; ufromfpxf64; ufromfpxf32x; ufromfpxf64x; ufromfpxf128;
}
}

12
math/bits/mathcalls.h
View File

@@ -400,25 +400,21 @@ __MATHCALLX (roundeven,, (_Mdouble_ __x), (__const__));
/* Round X to nearest signed integer value, not raising inexact, with
control of rounding direction and width of result. */
__MATHDECL (__intmax_t, fromfp,, (_Mdouble_ __x, int __round,
unsigned int __width));
__MATHCALL (fromfp,, (_Mdouble_ __x, int __round, unsigned int __width));
/* Round X to nearest unsigned integer value, not raising inexact,
with control of rounding direction and width of result. */
__MATHDECL (__uintmax_t, ufromfp,, (_Mdouble_ __x, int __round,
unsigned int __width));
__MATHCALL (ufromfp,, (_Mdouble_ __x, int __round, unsigned int __width));
/* Round X to nearest signed integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
__MATHDECL (__intmax_t, fromfpx,, (_Mdouble_ __x, int __round,
unsigned int __width));
__MATHCALL (fromfpx,, (_Mdouble_ __x, int __round, unsigned int __width));
/* Round X to nearest unsigned integer value, raising inexact for
non-integers, with control of rounding direction and width of
result. */
__MATHDECL (__uintmax_t, ufromfpx,, (_Mdouble_ __x, int __round,
unsigned int __width));
__MATHCALL (ufromfpx,, (_Mdouble_ __x, int __round, unsigned int __width));
/* Canonicalize floating-point representation. */
__MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x));

2
math/compat_fromfp.h
View File

@@ -1,4 +1,4 @@
/* Round to integer type. Common helper functions.
/* Round to integer type (pre-C23 version). Common helper functions.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.

117
math/fromfp.h Normal file
View File

@@ -0,0 +1,117 @@
/* Round to integer type (C23 version). Common helper functions.
Copyright (C) 2016-2025 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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <math-barriers.h>
#include <stdbool.h>
#include <stdint.h>
/* The including file should have defined UNSIGNED to 0 (signed return
type) or 1 (unsigned return type), INEXACT to 0 (no inexact
exceptions) or 1 (raise inexact exceptions), FLOAT to the floating
type for the function being defined, PREFIX to the prefix of
<float.h> macros for that type and SUFFIX to the suffix of <math.h>
functions for that type. */
#define M_CONCATX(X, Y) X ## Y
#define M_CONCAT(X, Y) M_CONCATX (X, Y)
#define M_SUF(F) M_CONCAT (F, SUFFIX)
#define M_MAX_EXP M_CONCAT (PREFIX, MAX_EXP)
/* Adjust WIDTH into a range sufficient to cover all possible finite
results from calls to this function. */
static unsigned int
fromfp_adjust_width (unsigned int width)
{
if (width > (UNSIGNED ? M_MAX_EXP : M_MAX_EXP + 1))
return UNSIGNED ? M_MAX_EXP : M_MAX_EXP + 1;
return width;
}
/* Return the maximum unbiased exponent for a rounded result (negative
if NEGATIVE is set) that might be in range for a call to a fromfp
function with width WIDTH (greater than 0, and not exceeding that
returned by fromfp_adjust_width). The result may still be out of
range in the case of negative arguments. */
static int
fromfp_max_exponent (bool negative, int width)
{
if (UNSIGNED)
return negative ? -1 : width - 1;
else
return negative ? width - 1 : width - 2;
}
/* Return the result of rounding an argument X in the rounding
direction ROUND. */
static FLOAT
fromfp_round (FLOAT x, int rm)
{
switch (rm)
{
case FP_INT_UPWARD:
return M_SUF (ceil) (x);
case FP_INT_DOWNWARD:
return M_SUF (floor) (x);
case FP_INT_TOWARDZERO:
default:
/* Unknown rounding directions are defined to mean unspecified
rounding; treat this as truncation. */
return M_SUF (trunc) (x);
case FP_INT_TONEARESTFROMZERO:
return M_SUF (round) (x);
case FP_INT_TONEAREST:
return M_SUF (roundeven) (x);
}
}
/* Handle a domain error for a call to a fromfp function. */
static FLOAT
fromfp_domain_error (void)
{
__set_errno (EDOM);
return (FLOAT) 0 / (FLOAT) 0;
}
/* X has rounded to RX, which is within range. Return RX, with
"inexact" raised if appropriate. */
static FLOAT
fromfp_return (FLOAT x, FLOAT rx)
{
if (INEXACT && rx != x)
{
/* There is no need for this to use the specific floating-point
type for which this header is included (and indeed 1 +
LDBL_MIN may not raise "inexact" for IBM long double). */
float force_inexact = 1.0f + FLT_MIN;
math_force_eval (force_inexact);
}
return rx;
}

93
math/gen-fromfp-tests-inputs
View File

@@ -96,76 +96,76 @@ i 0xfffffffffffff800ULL:64
/* Inputs with absolute value between 0 and 1. */
t min_subnorm_value a 0:1 1:1
t -min_subnorm_value a 0:1 -1:1
t -min_subnorm_value a -0:1 -1:1
t min_value a 0:1 1:1
t -min_value a 0:1 -1:1
t -min_value a -0:1 -1:1
t 0.1 a 0:1 1:1
t -0.1 a 0:1 -1:1
t -0.1 a -0:1 -1:1
t 0.25 a 0:1 1:1
t -0.25 a 0:1 -1:1
t -0.25 a -0:1 -1:1
t 0.499 a 0:1 1:1
t -0.499 a 0:1 -1:1
t -0.499 a -0:1 -1:1
t 0x0.ffffffp-1 a 0:1 1:1
t -0x0.ffffffp-1 a 0:1 -1:1
t -0x0.ffffffp-1 a -0:1 -1:1
#if MANT_DIG >= 53
t 0x0.fffffffffffff8p-1 a 0:1 1:1
t -0x0.fffffffffffff8p-1 a 0:1 -1:1
t -0x0.fffffffffffff8p-1 a -0:1 -1:1
#endif
#if MANT_DIG >= 64
t 0x0.ffffffffffffffffp-1 a 0:1 1:1
t -0x0.ffffffffffffffffp-1 a 0:1 -1:1
t -0x0.ffffffffffffffffp-1 a -0:1 -1:1
#endif
#if MANT_DIG >= 106
t 0x0.ffffffffffffffffffffffffffcp-1 a 0:1 1:1
t -0x0.ffffffffffffffffffffffffffcp-1 a 0:1 -1:1
t -0x0.ffffffffffffffffffffffffffcp-1 a -0:1 -1:1
#endif
#if MANT_DIG >= 113
t 0x0.ffffffffffffffffffffffffffff8p-1 a 0:1 1:1
t -0x0.ffffffffffffffffffffffffffff8p-1 a 0:1 -1:1
t -0x0.ffffffffffffffffffffffffffff8p-1 a -0:1 -1:1
#endif
t 0.5 be 0:1 1:1
t -0.5 be 0:1 -1:1
t -0.5 be -0:1 -1:1
t 0x1.000002p-1 c 0:1 1:1
t -0x1.000002p-1 c 0:1 -1:1
t -0x1.000002p-1 c -0:1 -1:1
#if MANT_DIG >= 53
t 0x1.0000000000001p-1 c 0:1 1:1
t -0x1.0000000000001p-1 c 0:1 -1:1
t -0x1.0000000000001p-1 c -0:1 -1:1
#endif
#if MANT_DIG >= 64
t 0x1.0000000000000002p-1 c 0:1 1:1
t -0x1.0000000000000002p-1 c 0:1 -1:1
t -0x1.0000000000000002p-1 c -0:1 -1:1
#endif
#if MANT_DIG >= 106
t 0x1.000000000000000000000000008p-1 c 0:1 1:1
t -0x1.000000000000000000000000008p-1 c 0:1 -1:1
t -0x1.000000000000000000000000008p-1 c -0:1 -1:1
#endif
#if MANT_DIG >= 113
t 0x1.0000000000000000000000000001p-1 c 0:1 1:1
t -0x1.0000000000000000000000000001p-1 c 0:1 -1:1
t -0x1.0000000000000000000000000001p-1 c -0:1 -1:1
#endif
t 0.501 c 0:1 1:1
t -0.501 c 0:1 -1:1
t -0.501 c -0:1 -1:1
t 0.75 c 0:1 1:1
t -0.75 c 0:1 -1:1
t -0.75 c -0:1 -1:1
t 0.9 c 0:1 1:1
t -0.9 c 0:1 -1:1
t -0.9 c -0:1 -1:1
t 0x0.ffffffp0 c 0:1 1:1
t -0x0.ffffffp0 c 0:1 -1:1
t -0x0.ffffffp0 c -0:1 -1:1
#if MANT_DIG >= 53
t 0x0.fffffffffffff8p0 c 0:1 1:1
t -0x0.fffffffffffff8p0 c 0:1 -1:1
t -0x0.fffffffffffff8p0 c -0:1 -1:1
#endif
#if MANT_DIG >= 64
t 0x0.ffffffffffffffffp0 c 0:1 1:1
t -0x0.ffffffffffffffffp0 c 0:1 -1:1
t -0x0.ffffffffffffffffp0 c -0:1 -1:1
#endif
#if MANT_DIG >= 106
t 0x0.ffffffffffffffffffffffffffcp0 c 0:1 1:1
t -0x0.ffffffffffffffffffffffffffcp0 c 0:1 -1:1
t -0x0.ffffffffffffffffffffffffffcp0 c -0:1 -1:1
#endif
#if MANT_DIG >= 113
t 0x0.ffffffffffffffffffffffffffff8p0 c 0:1 1:1
t -0x0.ffffffffffffffffffffffffffff8p0 c 0:1 -1:1
t -0x0.ffffffffffffffffffffffffffff8p0 c -0:1 -1:1
#endif
/* Various non-integer inputs. */
@@ -417,10 +417,43 @@ t 0x7fffffffffffffff.8p0 bo 0x7fffffffffffffffLL:63 0x8000000000000000ULL:64
#if MANT_DIG >= 72
t 0x7fffffffffffffff.7fp0 a 0x7fffffffffffffffLL:63 0x8000000000000000ULL:64
t 0x7fffffffffffffff.81p0 c 0x7fffffffffffffffLL:63 0x8000000000000000ULL:64
t 0xffffffffffffffff.7fp0 a 0xffffffffffffffffULL:64 0x10000000000000000ULL:65
t 0xffffffffffffffff.8p0 bo 0xffffffffffffffffULL:64 0x10000000000000000ULL:65
t 0xffffffffffffffff.81p0 c 0xffffffffffffffffULL:64 0x10000000000000000ULL:65
t -0x8000000000000000.7fp0 a -INT64_MAX-1:64 -0x8000000000000001LL:65
t -0x8000000000000000.8p0 be -INT64_MAX-1:64 -0x8000000000000001LL:65
t -0x8000000000000000.81p0 c -INT64_MAX-1:64 -0x8000000000000001LL:65
t 0xffffffffffffffff.7fp0 a 0xffffffffffffffffULL:64 0x1p64:65
t 0xffffffffffffffff.8p0 bo 0xffffffffffffffffULL:64 0x1p64:65
t 0xffffffffffffffff.81p0 c 0xffffffffffffffffULL:64 0x1p64:65
t -0x8000000000000000.7fp0 a -INT64_MAX-1:64 -0x8000000000000001p0:65
t -0x8000000000000000.8p0 be -INT64_MAX-1:64 -0x8000000000000001p0:65
t -0x8000000000000000.81p0 c -INT64_MAX-1:64 -0x8000000000000001p0:65
#endif
c23
/* Tests that are out of range for compat functions, OK for C23. */
i 0x1p64:65
i -0x1p64:65
i 0x1.fp64:65
i -0x1.fp64:66
i 0x1p127:128
i -0x1p127:128
i 0x1.fp127:128
i -0x1.fp127:129
#if MAX_EXP >= 1024
i 0x1p1023:1024
i -0x1p1023:1024
i 0x1.fp1023:1024
i -0x1.fp1023:1025
#endif
#if MAX_EXP >= 16384
i 0x1p16383:16384
i -0x1p16383:16384
i 0x1.fp16383:16384
i -0x1.fp16383:16385
#endif
#if MANT_DIG >= 80
t 0x7fffffffffffffffff.7fp0 a 0x7fffffffffffffffffp0:71 0x1p71:72
t 0x7fffffffffffffffff.81p0 c 0x7fffffffffffffffffp0:71 0x1p71:72
t 0xffffffffffffffffff.7fp0 a 0xffffffffffffffffffp0:72 0x1p72:73
t 0xffffffffffffffffff.8p0 bo 0xffffffffffffffffffp0:72 0x1p72:73
t 0xffffffffffffffffff.81p0 c 0xffffffffffffffffffp0:72 0x1p72:73
t -0x800000000000000000.7fp0 a -0x1p71:72 -0x800000000000000001p0:73
t -0x800000000000000000.8p0 be -0x1p71:72 -0x800000000000000001p0:73
t -0x800000000000000000.81p0 c -0x1p71:72 -0x800000000000000001p0:73
#endif

52
math/gen-fromfp-tests.py
View File

@@ -33,8 +33,10 @@
# the smallest type that can hold the value; for positive values, this
# is an unsigned type.
#
# Command-line argument is function to generate tests for. Any input
# lines not of the above form are just passed through unchanged.
# Command-line argument is function to generate tests for. A line
# starting "c23" terminates processing for the compat functions, and
# is otherwise ignored. Any other input lines not of the above form
# are just passed through unchanged.
#
# Note that the output of this script forms the largest part of the
# tests for the fromfp functions, but not the whole of those tests.
@@ -43,7 +45,15 @@ import sys
func = sys.argv[1]
invalid_res = 'IGNORE, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM'
if func.startswith('compat_'):
compat = True
func = func[len('compat_'):]
invalid_value = 'IGNORE'
else:
compat = False
invalid_value = 'qnan_value'
invalid_res = (invalid_value
+ ', NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM')
exact_res = 'NO_INEXACT_EXCEPTION|ERRNO_UNCHANGED'
if func == 'fromfpx' or func == 'ufromfpx':
inexact_res = 'INEXACT_EXCEPTION|ERRNO_UNCHANGED'
@@ -62,13 +72,19 @@ rm_away_neg = {'FP_INT_UPWARD': 'z',
'FP_INT_TOWARDZERO': 'z',
'FP_INT_TONEARESTFROMZERO': 'be',
'FP_INT_TONEAREST': 'bo'}
if unsigned:
test_macro = 'TEST_fiu_U'
if compat:
if unsigned:
test_macro = 'TEST_fiu_U'
else:
test_macro = 'TEST_fiu_M'
else:
test_macro = 'TEST_fiu_M'
test_macro = 'TEST_fiu_f'
for line in sys.stdin:
if line.startswith('i'):
if line.startswith('c23'):
if compat:
break
elif line.startswith('i'):
data = line.split()
val_width = data[1]
val, width = val_width.split(':')
@@ -81,14 +97,17 @@ for line in sys.stdin:
width_list = [0, 1]
if width > 2:
width_list.append(width - 1)
if width > 1 and width <= 64:
if width > 1 and (width <= 64 or not compat):
width_list.append(width)
if width < 64:
if width < 64 or not compat:
width_list.append(width + 1)
if width < 63:
width_list.append(64)
width_list = [(w, str(w)) for w in width_list]
width_list.append((64, 'UINT_MAX'))
if compat:
width_list.append((64, 'UINT_MAX'))
else:
width_list.append((1000000, 'UINT_MAX'))
for rm in rm_list:
for we in width_list:
w, ws = we
@@ -106,7 +125,7 @@ for line in sys.stdin:
z_width = int(z_width)
a, a_width = data[4].split(':')
a_width = int(a_width)
if unsigned and z.startswith('-'):
if unsigned and z.startswith('-') and z != '-0':
continue
negative = val.startswith('-')
if negative:
@@ -123,14 +142,19 @@ for line in sys.stdin:
width_list = [0, 1]
if width > 2:
width_list.append(width - 1)
if width > 1 and width <= 64:
if width > 1 and (width <= 64 or not compat):
width_list.append(width)
if width < 64:
if width < 64 or not compat:
width_list.append(width + 1)
if width < 63:
width_list.append(64)
width_list = [(w, str(w)) for w in width_list]
width_list.append((64, 'UINT_MAX'))
if compat:
width_list.append((64, 'UINT_MAX'))
else:
width_list.append((1000000, 'UINT_MAX'))
if res == '-0':
res = '0' if compat else 'minus_zero'
for we in width_list:
w, ws = we
if w < width or (unsigned and res.startswith('-')):

8
math/gen-tgmath-tests.py
View File

@@ -726,10 +726,10 @@ class Tests(object):
self.add_tests('fminmag', 'r', ['r', 'r'])
self.add_tests('fmaxmag', 'r', ['r', 'r'])
self.add_tests('llogb', 'long int', ['r'])
self.add_tests('fromfp', 'intmax_t', ['r', 'int', 'unsigned int'])
self.add_tests('fromfpx', 'intmax_t', ['r', 'int', 'unsigned int'])
self.add_tests('ufromfp', 'uintmax_t', ['r', 'int', 'unsigned int'])
self.add_tests('ufromfpx', 'uintmax_t', ['r', 'int', 'unsigned int'])
self.add_tests('fromfp', 'r', ['r', 'int', 'unsigned int'])
self.add_tests('fromfpx', 'r', ['r', 'int', 'unsigned int'])
self.add_tests('ufromfp', 'r', ['r', 'int', 'unsigned int'])
self.add_tests('ufromfpx', 'r', ['r', 'int', 'unsigned int'])
for fn, args in (('add', 2), ('div', 2), ('fma', 3), ('mul', 2),
('sqrt', 1), ('sub', 2)):
for ret, prefix in (('float', 'f'),

28
math/libm-test-compat_fromfp.inc
View File

@@ -1,4 +1,4 @@
/* Test fromfp.
/* Test fromfp (pre-C23 compat version).
Copyright (C) 1997-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -16,9 +16,23 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <shlib-compat.h>
#include <first-versions.h>
#include "libm-test-driver.c"
static const struct test_fiu_M_data fromfp_test_data[] =
#define CONCATX(x, y) x ## y
#define CONCAT(x, y) CONCATX (x, y)
#define COMPAT_VER CONCAT (FIRST_VERSION_libm_, FUNC_TEST (fromfp))
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
intmax_t FUNC_TEST (compat_fromfp) (FLOAT, int, unsigned int);
compat_symbol_reference (libm,
FUNC_TEST (compat_fromfp),
FUNC_TEST (fromfp),
COMPAT_VER);
static const struct test_fiu_M_data compat_fromfp_test_data[] =
{
/* Infinity, NaN and values that are definitely out of range
(large values of width count as the width of the return
@@ -11928,15 +11942,19 @@ static const struct test_fiu_M_data fromfp_test_data[] =
};
static void
fromfp_test (void)
compat_fromfp_test (void)
{
ALL_RM_TEST (fromfp, 1, fromfp_test_data, RUN_TEST_LOOP_fiu_M, END);
ALL_RM_TEST (compat_fromfp, 1, compat_fromfp_test_data, RUN_TEST_LOOP_fiu_M, END);
}
#endif
static void
do_test (void)
{
fromfp_test ();
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
compat_fromfp_test ();
#endif
}
/*

28
math/libm-test-compat_fromfpx.inc
View File

@@ -1,4 +1,4 @@
/* Test fromfpx.
/* Test fromfpx (pre-C23 compat version).
Copyright (C) 1997-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -16,9 +16,23 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <shlib-compat.h>
#include <first-versions.h>
#include "libm-test-driver.c"
static const struct test_fiu_M_data fromfpx_test_data[] =
#define CONCATX(x, y) x ## y
#define CONCAT(x, y) CONCATX (x, y)
#define COMPAT_VER CONCAT (FIRST_VERSION_libm_, FUNC_TEST (fromfpx))
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
intmax_t FUNC_TEST (compat_fromfpx) (FLOAT, int, unsigned int);
compat_symbol_reference (libm,
FUNC_TEST (compat_fromfpx),
FUNC_TEST (fromfpx),
COMPAT_VER);
static const struct test_fiu_M_data compat_fromfpx_test_data[] =
{
/* Infinity, NaN and values that are definitely out of range
(large values of width count as the width of the return
@@ -11928,15 +11942,19 @@ static const struct test_fiu_M_data fromfpx_test_data[] =
};
static void
fromfpx_test (void)
compat_fromfpx_test (void)
{
ALL_RM_TEST (fromfpx, 1, fromfpx_test_data, RUN_TEST_LOOP_fiu_M, END);
ALL_RM_TEST (compat_fromfpx, 1, compat_fromfpx_test_data, RUN_TEST_LOOP_fiu_M, END);
}
#endif
static void
do_test (void)
{
fromfpx_test ();
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
compat_fromfpx_test ();
#endif
}
/*

28
math/libm-test-compat_ufromfp.inc
View File

@@ -1,4 +1,4 @@
/* Test ufromfp.
/* Test ufromfp (pre-C23 compat version).
Copyright (C) 1997-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -16,9 +16,23 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <shlib-compat.h>
#include <first-versions.h>
#include "libm-test-driver.c"
static const struct test_fiu_U_data ufromfp_test_data[] =
#define CONCATX(x, y) x ## y
#define CONCAT(x, y) CONCATX (x, y)
#define COMPAT_VER CONCAT (FIRST_VERSION_libm_, FUNC_TEST (ufromfp))
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
uintmax_t FUNC_TEST (compat_ufromfp) (FLOAT, int, unsigned int);
compat_symbol_reference (libm,
FUNC_TEST (compat_ufromfp),
FUNC_TEST (ufromfp),
COMPAT_VER);
static const struct test_fiu_U_data compat_ufromfp_test_data[] =
{
/* Infinity, NaN and values that are definitely out of range
(large values of width count as the width of the return
@@ -6827,15 +6841,19 @@ static const struct test_fiu_U_data ufromfp_test_data[] =
};
static void
ufromfp_test (void)
compat_ufromfp_test (void)
{
ALL_RM_TEST (ufromfp, 1, ufromfp_test_data, RUN_TEST_LOOP_fiu_U, END);
ALL_RM_TEST (compat_ufromfp, 1, compat_ufromfp_test_data, RUN_TEST_LOOP_fiu_U, END);
}
#endif
static void
do_test (void)
{
ufromfp_test ();
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
compat_ufromfp_test ();
#endif
}
/*

28
math/libm-test-compat_ufromfpx.inc
View File

@@ -1,4 +1,4 @@
/* Test ufromfpx.
/* Test ufromfpx (pre-C23 compat version).
Copyright (C) 1997-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -16,9 +16,23 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <shlib-compat.h>
#include <first-versions.h>
#include "libm-test-driver.c"
static const struct test_fiu_U_data ufromfpx_test_data[] =
#define CONCATX(x, y) x ## y
#define CONCAT(x, y) CONCATX (x, y)
#define COMPAT_VER CONCAT (FIRST_VERSION_libm_, FUNC_TEST (ufromfpx))
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
uintmax_t FUNC_TEST (compat_ufromfpx) (FLOAT, int, unsigned int);
compat_symbol_reference (libm,
FUNC_TEST (compat_ufromfpx),
FUNC_TEST (ufromfpx),
COMPAT_VER);
static const struct test_fiu_U_data compat_ufromfpx_test_data[] =
{
/* Infinity, NaN and values that are definitely out of range
(large values of width count as the width of the return
@@ -6827,15 +6841,19 @@ static const struct test_fiu_U_data ufromfpx_test_data[] =
};
static void
ufromfpx_test (void)
compat_ufromfpx_test (void)
{
ALL_RM_TEST (ufromfpx, 1, ufromfpx_test_data, RUN_TEST_LOOP_fiu_U, END);
ALL_RM_TEST (compat_ufromfpx, 1, compat_ufromfpx_test_data, RUN_TEST_LOOP_fiu_U, END);
}
#endif
static void
do_test (void)
{
ufromfpx_test ();
#if TEST_COMPAT (libm, COMPAT_VER, GLIBC_2_43)
compat_ufromfpx_test ();
#endif
}
/*

13
math/libm-test-driver.c
View File

@@ -254,6 +254,18 @@ struct test_fff_f_data
int exceptions;
} rd, rn, rz, ru;
};
struct test_fiu_f_data
{
const char *arg_str;
FLOAT arg1;
int arg2;
unsigned int arg3;
struct
{
FLOAT expected;
int exceptions;
} rd, rn, rz, ru;
};
struct test_fiu_M_data
{
const char *arg_str;
@@ -580,6 +592,7 @@ struct test_Ff_b1_data
ROUND_RESTORE_ ## ROUNDING_MODE
#define RUN_TEST_LOOP_fff_f RUN_TEST_LOOP_3_f
#define RUN_TEST_LOOP_aaa_f RUN_TEST_LOOP_3_f
#define RUN_TEST_LOOP_fiu_f RUN_TEST_LOOP_3_f
#define RUN_TEST_fiu_M(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
EXPECTED, EXCEPTIONS) \
do \

12885
math/libm-test-fromfp.inc Normal file
View File

File diff suppressed because it is too large Load Diff

12885
math/libm-test-fromfpx.inc Normal file
View File

File diff suppressed because it is too large Load Diff

7327
math/libm-test-ufromfp.inc Normal file
View File

File diff suppressed because it is too large Load Diff

7327
math/libm-test-ufromfpx.inc Normal file
View File

File diff suppressed because it is too large Load Diff

3
math/math.h
View File

@@ -33,9 +33,6 @@
__BEGIN_DECLS
/* Get definitions of __intmax_t and __uintmax_t. */
#include <bits/types.h>
/* Get machine-dependent vector math functions declarations. */
#include <bits/math-vector.h>

10
math/test-tgmath-ret.c
View File

@@ -30,8 +30,6 @@ DIAG_IGNORE_NEEDS_COMMENT_CLANG (13, "-Wunneeded-internal-declaration");
static float fx;
static double dx;
static long double lx;
static int rm = FP_INT_UPWARD;
static unsigned int width = 64;
static int errors = 0;
DIAG_POP_NEEDS_COMMENT_CLANG;
@@ -70,10 +68,6 @@ CHECK_RET_CONST(lrint, long)
CHECK_RET_CONST(lround, long)
CHECK_RET_CONST(llrint, long long)
CHECK_RET_CONST(llround, long long)
CHECK_RET_CONST(fromfp, intmax_t, rm, width)
CHECK_RET_CONST(ufromfp, uintmax_t, rm, width)
CHECK_RET_CONST(fromfpx, intmax_t, rm, width)
CHECK_RET_CONST(ufromfpx, uintmax_t, rm, width)
static int
do_test (void)
@@ -84,10 +78,6 @@ do_test (void)
check_return_lround ();
check_return_llrint ();
check_return_llround ();
check_return_fromfp ();
check_return_ufromfp ();
check_return_fromfpx ();
check_return_ufromfpx ();
printf ("%zd\n", sizeof (carg (lx)));

22
math/test-tgmath.c
View File

@@ -228,8 +228,6 @@ F(compile_test) (void)
int saved_count;
long int j;
long long int k = 2;
intmax_t m;
uintmax_t um;
a = cos (cos (x));
a = cospi (cospi (x));
@@ -287,8 +285,8 @@ F(compile_test) (void)
b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i);
j = lrint (x) + lround (a);
k = llrint (b) + llround (c);
m = fromfp (a, FP_INT_UPWARD, 2) + fromfpx (b, FP_INT_DOWNWARD, 3);
um = ufromfp (c, FP_INT_TONEAREST, 4) + ufromfpx (a, FP_INT_TOWARDZERO, 5);
c = fromfp (a, FP_INT_UPWARD, 2) + fromfpx (b, FP_INT_DOWNWARD, 3);
c = ufromfp (c, FP_INT_TONEAREST, 4) + ufromfpx (a, FP_INT_TOWARDZERO, 5);
a = erf (erf (x));
b = erfc (erfc (a));
a = tgamma (tgamma (x));
@@ -324,7 +322,7 @@ F(compile_test) (void)
c = fma (i, b, i);
a = pow (i, c);
#endif
x = a + b + c + i + j + k + m + um;
x = a + b + c + i + j + k;
saved_count = count;
if (ccount != 0)
@@ -417,9 +415,9 @@ F(compile_test) (void)
a = remquo (y, y, &i);
j = lrint (y) + lround (y);
k = llrint (y) + llround (y);
m = fromfp (y, FP_INT_UPWARD, 6) + fromfpx (y, FP_INT_DOWNWARD, 7);
um = (ufromfp (y, FP_INT_TONEAREST, 8)
+ ufromfpx (y, FP_INT_TOWARDZERO, 9));
b = fromfp (y, FP_INT_UPWARD, 6) + fromfpx (y, FP_INT_DOWNWARD, 7);
b = (ufromfp (y, FP_INT_TONEAREST, 8)
+ ufromfpx (y, FP_INT_TOWARDZERO, 9));
a = erf (y);
a = erfc (y);
a = tgamma (y);
@@ -947,7 +945,7 @@ long long int
return x;
}
intmax_t
TYPE
(F(fromfp)) (TYPE x, int round, unsigned int width)
{
++count;
@@ -955,7 +953,7 @@ intmax_t
return x;
}
intmax_t
TYPE
(F(fromfpx)) (TYPE x, int round, unsigned int width)
{
++count;
@@ -963,7 +961,7 @@ intmax_t
return x;
}
uintmax_t
TYPE
(F(ufromfp)) (TYPE x, int round, unsigned int width)
{
++count;
@@ -971,7 +969,7 @@ uintmax_t
return x;
}
uintmax_t
TYPE
(F(ufromfpx)) (TYPE x, int round, unsigned int width)
{
++count;

37
math/tgmath.h
View File

@@ -386,7 +386,7 @@
# define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \
__TGMATH_3 (Fct, (Val1), (Val2), (Val3))
# endif
# define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \
# define __TGMATH_TERNARY_FIRST_REAL_ONLY(Val1, Val2, Val3, Fct) \
__TGMATH_3 (Fct, (Val1), (Val2), (Val3))
# define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \
__TGMATH_1C (Fct, Cfct, (Val))
@@ -520,14 +520,17 @@
# endif
# if !__HAVE_BUILTIN_TGMATH
# define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \
(__extension__ ((sizeof (+(Val1)) == sizeof (double) \
|| __builtin_classify_type (Val1) != 8) \
? Fct (Val1, Val2, Val3) \
: (sizeof (+(Val1)) == sizeof (float)) \
? Fct##f (Val1, Val2, Val3) \
: __TGMATH_F128 ((Val1), Fct, (Val1, Val2, Val3)) \
__tgml(Fct) (Val1, Val2, Val3)))
# define __TGMATH_TERNARY_FIRST_REAL_ONLY(Val1, Val2, Val3, Fct) \
(__extension__ ((sizeof (+(Val1)) == sizeof (double) \
|| __builtin_classify_type (Val1) != 8) \
? (__tgmath_real_type (Val1)) Fct (Val1, Val2, Val3) \
: (sizeof (+(Val1)) == sizeof (float)) \
? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2, Val3) \
: __TGMATH_F128 ((Val1), \
(__tgmath_real_type (Val1)) Fct, \
(Val1, Val2, Val3)) \
(__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2, \
Val3)))
/* XXX This definition has to be changed as soon as the compiler understands
the imaginary keyword. */
@@ -1056,17 +1059,17 @@
/* Round X to nearest integer value, rounding halfway cases to even. */
# define roundeven(Val) __TGMATH_UNARY_REAL_ONLY (Val, roundeven)
# define fromfp(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfp)
# define fromfp(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, fromfp)
# define ufromfp(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfp)
# define ufromfp(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, ufromfp)
# define fromfpx(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, fromfpx)
# define fromfpx(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, fromfpx)
# define ufromfpx(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_RET_ONLY (Val1, Val2, Val3, ufromfpx)
# define ufromfpx(Val1, Val2, Val3) \
__TGMATH_TERNARY_FIRST_REAL_ONLY (Val1, Val2, Val3, ufromfpx)
/* Like ilogb, but returning long int. */
# define llogb(Val) __TGMATH_UNARY_REAL_RET_ONLY (Val, llogb)

16
sysdeps/ieee754/dbl-64/s_compat_fromfp.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfp
#define FUNC __compat_fromfp
#include <s_compat_fromfp_main.c>
libm_alias_double (__fromfp, fromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_double (__compat_fromfp, fromfp)
#endif

9
sysdeps/ieee754/dbl-64/s_compat_fromfp_main.c
View File

@@ -1,4 +1,4 @@
/* Round to integer type. dbl-64 version.
/* Round to integer type (pre-C23 compat version). dbl-64 version.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -23,6 +23,8 @@
#include <libm-alias-double.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#include <first-versions.h>
#define BIAS 0x3ff
#define MANT_DIG 53
@@ -33,9 +35,11 @@
# define RET_TYPE intmax_t
#endif
#include <compat_fromfp.h>
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# include <compat_fromfp.h>
RET_TYPE
attribute_compat_text_section
FUNC (double x, int round, unsigned int width)
{
if (width > INTMAX_WIDTH)
@@ -81,3 +85,4 @@ FUNC (double x, int round, unsigned int width)
return fromfp_round_and_return (negative, uret, half_bit, more_bits, round,
exponent, max_exponent, width);
}
#endif

16
sysdeps/ieee754/dbl-64/s_compat_fromfpx.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpx
#define FUNC __compat_fromfpx
#include <s_compat_fromfp_main.c>
libm_alias_double (__fromfpx, fromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_double (__compat_fromfpx, fromfpx)
#endif

16
sysdeps/ieee754/dbl-64/s_compat_ufromfp.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfp
#define FUNC __compat_ufromfp
#include <s_compat_fromfp_main.c>
libm_alias_double (__ufromfp, ufromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_double (__compat_ufromfp, ufromfp)
#endif

16
sysdeps/ieee754/dbl-64/s_compat_ufromfpx.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpx
#define FUNC __compat_ufromfpx
#include <s_compat_fromfp_main.c>
libm_alias_double (__ufromfpx, ufromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_double (__compat_ufromfpx, ufromfpx)
#endif

16
sysdeps/ieee754/dbl-64/s_fromfp.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfp
#include <s_fromfp_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_double (__fromfp, fromfp)

55
sysdeps/ieee754/dbl-64/s_fromfp_main.c Normal file
View File

@@ -0,0 +1,55 @@
/* Round to integer type (C23 version). dbl-64 version.
Copyright (C) 2016-2025 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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fenv.h>
#include <math.h>
#include <math_private.h>
#include <libm-alias-double.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#define FLOAT double
#define PREFIX DBL_
#define SUFFIX
#define BIAS 0x3ff
#define MANT_DIG 53
#include <fromfp.h>
double
FUNC (double x, int round, unsigned int width)
{
width = fromfp_adjust_width (width);
double rx = fromfp_round (x, round);
if (width == 0 || !isfinite (rx))
return fromfp_domain_error ();
uint64_t ix;
EXTRACT_WORDS64 (ix, rx);
bool negative = (ix & 0x8000000000000000ULL) != 0;
ix &= 0x7fffffffffffffffULL;
int exponent = ix >> (MANT_DIG - 1);
exponent -= BIAS;
int max_exponent = fromfp_max_exponent (negative, width);
ix &= ((1ULL << (MANT_DIG - 1)) - 1);
if (exponent > max_exponent
|| (!UNSIGNED && negative && exponent == max_exponent && ix != 0))
return fromfp_domain_error ();
return fromfp_return (x, rx);
}

16
sysdeps/ieee754/dbl-64/s_fromfpx.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpx
#include <s_fromfp_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_double (__fromfpx, fromfpx)

16
sysdeps/ieee754/dbl-64/s_ufromfp.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfp
#include <s_fromfp_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_double (__ufromfp, ufromfp)

16
sysdeps/ieee754/dbl-64/s_ufromfpx.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpx
#include <s_fromfp_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_double (__ufromfpx, ufromfpx)

19
sysdeps/ieee754/float128/s_compat_fromfpf128.c
View File

@@ -1,6 +1,21 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpf128
#define FUNC __compat_fromfpf128
#include <float128_private.h>
#include "../ldbl-128/s_compat_fromfpl_main.c"
libm_alias_float128 (__fromfp, fromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
libm_alias_float128 (__compat_fromfp, fromfp)
#endif

19
sysdeps/ieee754/float128/s_compat_fromfpxf128.c
View File

@@ -1,6 +1,21 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxf128
#define FUNC __compat_fromfpxf128
#include <float128_private.h>
#include "../ldbl-128/s_compat_fromfpl_main.c"
libm_alias_float128 (__fromfpx, fromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
libm_alias_float128 (__compat_fromfpx, fromfpx)
#endif

19
sysdeps/ieee754/float128/s_compat_ufromfpf128.c
View File

@@ -1,6 +1,21 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpf128
#define FUNC __compat_ufromfpf128
#include <float128_private.h>
#include "../ldbl-128/s_compat_fromfpl_main.c"
libm_alias_float128 (__ufromfp, ufromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
libm_alias_float128 (__compat_ufromfp, ufromfp)
#endif

19
sysdeps/ieee754/float128/s_compat_ufromfpxf128.c
View File

@@ -1,6 +1,21 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxf128
#define FUNC __compat_ufromfpxf128
#include <float128_private.h>
#include "../ldbl-128/s_compat_fromfpl_main.c"
libm_alias_float128 (__ufromfpx, ufromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
libm_alias_float128 (__compat_ufromfpx, ufromfpx)
#endif

20
sysdeps/ieee754/float128/s_fromfpf128.c Normal file
View File

@@ -0,0 +1,20 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpf128
#include <float128_private.h>
#include "../ldbl-128/s_fromfpl_main.c"
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
#endif
libm_alias_float128 (__fromfp, fromfp)

20
sysdeps/ieee754/float128/s_fromfpxf128.c Normal file
View File

@@ -0,0 +1,20 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxf128
#include <float128_private.h>
#include "../ldbl-128/s_fromfpl_main.c"
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
#endif
libm_alias_float128 (__fromfpx, fromfpx)

20
sysdeps/ieee754/float128/s_ufromfpf128.c Normal file
View File

@@ -0,0 +1,20 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpf128
#include <float128_private.h>
#include "../ldbl-128/s_fromfpl_main.c"
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
#endif
libm_alias_float128 (__ufromfp, ufromfp)

20
sysdeps/ieee754/float128/s_ufromfpxf128.c Normal file
View File

@@ -0,0 +1,20 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxf128
#include <float128_private.h>
#include "../ldbl-128/s_fromfpl_main.c"
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
# undef libm_alias_float128_other_r_ldbl
# define libm_alias_float128_other_r_ldbl(from, to, r) \
weak_alias (from ## f128 ## r, __ ## to ## ieee128 ## r)
#endif
libm_alias_float128 (__ufromfpx, ufromfpx)

16
sysdeps/ieee754/flt-32/s_compat_fromfpf.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpf
#define FUNC __compat_fromfpf
#include <s_compat_fromfpf_main.c>
libm_alias_float (__fromfp, fromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_float (__compat_fromfp, fromfp)
#endif

9
sysdeps/ieee754/flt-32/s_compat_fromfpf_main.c
View File

@@ -1,4 +1,4 @@
/* Round to integer type. flt-32 version.
/* Round to integer type (pre-C23 compat version). flt-32 version.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -23,6 +23,8 @@
#include <libm-alias-float.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#include <first-versions.h>
#define BIAS 0x7f
#define MANT_DIG 24
@@ -33,9 +35,11 @@
# define RET_TYPE intmax_t
#endif
#include <compat_fromfp.h>
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# include <compat_fromfp.h>
RET_TYPE
attribute_compat_text_section
FUNC (float x, int round, unsigned int width)
{
if (width > INTMAX_WIDTH)
@@ -81,3 +85,4 @@ FUNC (float x, int round, unsigned int width)
return fromfp_round_and_return (negative, uret, half_bit, more_bits, round,
exponent, max_exponent, width);
}
#endif

16
sysdeps/ieee754/flt-32/s_compat_fromfpxf.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxf
#define FUNC __compat_fromfpxf
#include <s_compat_fromfpf_main.c>
libm_alias_float (__fromfpx, fromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_float (__compat_fromfpx, fromfpx)
#endif

16
sysdeps/ieee754/flt-32/s_compat_ufromfpf.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpf
#define FUNC __compat_ufromfpf
#include <s_compat_fromfpf_main.c>
libm_alias_float (__ufromfp, ufromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_float (__compat_ufromfp, ufromfp)
#endif

16
sysdeps/ieee754/flt-32/s_compat_ufromfpxf.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxf
#define FUNC __compat_ufromfpxf
#include <s_compat_fromfpf_main.c>
libm_alias_float (__ufromfpx, ufromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_float (__compat_ufromfpx, ufromfpx)
#endif

16
sysdeps/ieee754/flt-32/s_fromfpf.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpf
#include <s_fromfpf_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_float (__fromfp, fromfp)

55
sysdeps/ieee754/flt-32/s_fromfpf_main.c Normal file
View File

@@ -0,0 +1,55 @@
/* Round to integer type (C23 version). flt-32 version.
Copyright (C) 2016-2025 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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fenv.h>
#include <math.h>
#include <math_private.h>
#include <libm-alias-float.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#define FLOAT float
#define PREFIX FLT_
#define SUFFIX f
#define BIAS 0x7f
#define MANT_DIG 24
#include <fromfp.h>
float
FUNC (float x, int round, unsigned int width)
{
width = fromfp_adjust_width (width);
float rx = fromfp_round (x, round);
if (width == 0 || !isfinite (rx))
return fromfp_domain_error ();
uint32_t ix;
GET_FLOAT_WORD (ix, rx);
bool negative = (ix & 0x80000000) != 0;
ix &= 0x7fffffff;
int exponent = ix >> (MANT_DIG - 1);
exponent -= BIAS;
int max_exponent = fromfp_max_exponent (negative, width);
ix &= ((1U << (MANT_DIG - 1)) - 1);
if (exponent > max_exponent
|| (!UNSIGNED && negative && exponent == max_exponent && ix != 0))
return fromfp_domain_error ();
return fromfp_return (x, rx);
}

16
sysdeps/ieee754/flt-32/s_fromfpxf.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxf
#include <s_fromfpf_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_float (__fromfpx, fromfpx)

16
sysdeps/ieee754/flt-32/s_ufromfpf.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpf
#include <s_fromfpf_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_float (__ufromfp, ufromfp)

16
sysdeps/ieee754/flt-32/s_ufromfpxf.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxf
#include <s_fromfpf_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_float (__ufromfpx, ufromfpx)

4
sysdeps/ieee754/ldbl-128/Makefile
View File

@@ -73,6 +73,8 @@ CFLAGS-s_fmull.c += -fno-builtin-f32mulf64x -fno-builtin-f32mulf128
CFLAGS-s_frexpl.c += -fno-builtin-frexpf64x -fno-builtin-frexpf128
CFLAGS-s_compat_fromfpl.c += -fno-builtin-fromfpf64x -fno-builtin-fromfpf128
CFLAGS-s_compat_fromfpxl.c += -fno-builtin-fromfpxf64x -fno-builtin-fromfpxf128
CFLAGS-s_fromfpl.c += -fno-builtin-fromfpf64x -fno-builtin-fromfpf128
CFLAGS-s_fromfpxl.c += -fno-builtin-fromfpxf64x -fno-builtin-fromfpxf128
CFLAGS-s_fsqrtl.c += -fno-builtin-f32sqrtf64x -fno-builtin-f32sqrtf128
CFLAGS-s_fsubl.c += -fno-builtin-f32subf64x -fno-builtin-f32subf128
CFLAGS-s_getpayloadl.c += -fno-builtin-getpayloadf64x -fno-builtin-getpayloadf128
@@ -122,6 +124,8 @@ CFLAGS-s_totalordermagl.c += -fno-builtin-totalordermagf64x -fno-builtin-totalor
CFLAGS-s_truncl.c += -fno-builtin-truncf64x -fno-builtin-truncf128
CFLAGS-s_compat_ufromfpl.c += -fno-builtin-ufromfpf64x -fno-builtin-ufromfpf128
CFLAGS-s_compat_ufromfpxl.c += -fno-builtin-ufromfpxf64x -fno-builtin-ufromfpxf128
CFLAGS-s_ufromfpl.c += -fno-builtin-ufromfpf64x -fno-builtin-ufromfpf128
CFLAGS-s_ufromfpxl.c += -fno-builtin-ufromfpxf64x -fno-builtin-ufromfpxf128
CFLAGS-s_y0l.c += -fno-builtin-y0f64x -fno-builtin-y0f128
CFLAGS-s_y1l.c += -fno-builtin-y1f64x -fno-builtin-y1f128
CFLAGS-s_ynl.c += -fno-builtin-ynf64x -fno-builtin-ynf128

16
sysdeps/ieee754/ldbl-128/s_compat_fromfpl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpl
#define FUNC __compat_fromfpl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__fromfp, fromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_fromfp, fromfp)
#endif

9
sysdeps/ieee754/ldbl-128/s_compat_fromfpl_main.c
View File

@@ -1,4 +1,4 @@
/* Round to integer type. ldbl-128 version.
/* Round to integer type (pre-C23 compat version). ldbl-128 version.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -23,6 +23,8 @@
#include <libm-alias-ldouble.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#include <first-versions.h>
#define BIAS 0x3fff
#define MANT_DIG 113
@@ -33,9 +35,11 @@
# define RET_TYPE intmax_t
#endif
#include <compat_fromfp.h>
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# include <compat_fromfp.h>
RET_TYPE
attribute_compat_text_section
FUNC (_Float128 x, int round, unsigned int width)
{
if (width > INTMAX_WIDTH)
@@ -89,3 +93,4 @@ FUNC (_Float128 x, int round, unsigned int width)
return fromfp_round_and_return (negative, uret, half_bit, more_bits, round,
exponent, max_exponent, width);
}
#endif

16
sysdeps/ieee754/ldbl-128/s_compat_fromfpxl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxl
#define FUNC __compat_fromfpxl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__fromfpx, fromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_fromfpx, fromfpx)
#endif

16
sysdeps/ieee754/ldbl-128/s_compat_ufromfpl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpl
#define FUNC __compat_ufromfpl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__ufromfp, ufromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_ufromfp, ufromfp)
#endif

16
sysdeps/ieee754/ldbl-128/s_compat_ufromfpxl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxl
#define FUNC __compat_ufromfpxl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__ufromfpx, ufromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_ufromfpx, ufromfpx)
#endif

16
sysdeps/ieee754/ldbl-128/s_fromfpl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__fromfp, fromfp)

55
sysdeps/ieee754/ldbl-128/s_fromfpl_main.c Normal file
View File

@@ -0,0 +1,55 @@
/* Round to integer type (C23 version). ldbl-128 version.
Copyright (C) 2016-2025 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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fenv.h>
#include <math.h>
#include <math_private.h>
#include <libm-alias-ldouble.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#define FLOAT _Float128
#define PREFIX LDBL_
#define SUFFIX l
#define BIAS 0x3fff
#define MANT_DIG 113
#include <fromfp.h>
_Float128
FUNC (_Float128 x, int round, unsigned int width)
{
width = fromfp_adjust_width (width);
_Float128 rx = fromfp_round (x, round);
if (width == 0 || !isfinite (rx))
return fromfp_domain_error ();
uint64_t hx, lx;
GET_LDOUBLE_WORDS64 (hx, lx, rx);
bool negative = (hx & 0x8000000000000000ULL) != 0;
hx &= 0x7fffffffffffffffULL;
int exponent = hx >> (MANT_DIG - 1 - 64);
exponent -= BIAS;
int max_exponent = fromfp_max_exponent (negative, width);
hx &= ((1ULL << (MANT_DIG - 1 - 64)) - 1);
if (exponent > max_exponent
|| (!UNSIGNED && negative && exponent == max_exponent && (hx | lx) != 0))
return fromfp_domain_error ();
return fromfp_return (x, rx);
}

16
sysdeps/ieee754/ldbl-128/s_fromfpxl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__fromfpx, fromfpx)

16
sysdeps/ieee754/ldbl-128/s_ufromfpl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__ufromfp, ufromfp)

16
sysdeps/ieee754/ldbl-128/s_ufromfpxl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__ufromfpx, ufromfpx)

9
sysdeps/ieee754/ldbl-128ibm-compat/Makefile
View File

@@ -391,6 +391,15 @@ ifeq ($(subdir),math)
# support. Thus, they can only correctly be used with ibm128.
CFLAGS-test-ldouble-compat_totalorder.c += -mabi=ibmlongdouble
CFLAGS-test-ldouble-compat_totalordermag.c += -mabi=ibmlongdouble
# The compatibility tests for fromfp functions access particular
# versioned symbols by name, and those symbols are for the ibm128
# format. (It would also be possible to test the *ieee128 compat
# symbols, but these tests don't do so.)
CFLAGS-test-ldouble-compat_fromfp.c += -mabi=ibmlongdouble
CFLAGS-test-ldouble-compat_fromfpx.c += -mabi=ibmlongdouble
CFLAGS-test-ldouble-compat_ufromfp.c += -mabi=ibmlongdouble
CFLAGS-test-ldouble-compat_ufromfpx.c += -mabi=ibmlongdouble
endif
ifeq ($(subdir), stdio-common)

6
sysdeps/ieee754/ldbl-128ibm-compat/Versions
View File

@@ -160,6 +160,12 @@ libm {
__rootnieee128;
__rsqrtieee128;
}
GLIBC_2.43 {
__fromfpieee128;
__fromfpxieee128;
__ufromfpieee128;
__ufromfpxieee128;
}
}
libc {
LDBL_IBM128_VERSION {

16
sysdeps/ieee754/ldbl-128ibm/s_compat_fromfpl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpl
#define FUNC __compat_fromfpl
#include <s_compat_fromfpl_main.c>
weak_alias (__fromfpl, fromfpl)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
weak_alias (__compat_fromfpl, fromfpl)
#endif

9
sysdeps/ieee754/ldbl-128ibm/s_compat_fromfpl_main.c
View File

@@ -1,4 +1,4 @@
/* Round to integer type. ldbl-128ibm version.
/* Round to integer type (pre-C23 compat version). ldbl-128ibm version.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -22,6 +22,8 @@
#include <math_private.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#include <first-versions.h>
#define BIAS 0x3ff
#define MANT_DIG 53
@@ -32,9 +34,11 @@
# define RET_TYPE intmax_t
#endif
#include <compat_fromfp.h>
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# include <compat_fromfp.h>
RET_TYPE
attribute_compat_text_section
FUNC (long double x, int round, unsigned int width)
{
double hi, lo;
@@ -145,3 +149,4 @@ FUNC (long double x, int round, unsigned int width)
return fromfp_round_and_return (negative, uret, half_bit, more_bits, round,
exponent, max_exponent, width);
}
#endif

16
sysdeps/ieee754/ldbl-128ibm/s_compat_fromfpxl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxl
#define FUNC __compat_fromfpxl
#include <s_compat_fromfpl_main.c>
weak_alias (__fromfpxl, fromfpxl)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
weak_alias (__compat_fromfpxl, fromfpxl)
#endif

16
sysdeps/ieee754/ldbl-128ibm/s_compat_ufromfpl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpl
#define FUNC __compat_ufromfpl
#include <s_compat_fromfpl_main.c>
weak_alias (__ufromfpl, ufromfpl)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
weak_alias (__compat_ufromfpl, ufromfpl)
#endif

16
sysdeps/ieee754/ldbl-128ibm/s_compat_ufromfpxl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxl
#define FUNC __compat_ufromfpxl
#include <s_compat_fromfpl_main.c>
weak_alias (__ufromfpxl, ufromfpxl)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
weak_alias (__compat_ufromfpxl, ufromfpxl)
#endif

16
sysdeps/ieee754/ldbl-128ibm/s_fromfpl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
weak_alias (__fromfpl, fromfpl)

62
sysdeps/ieee754/ldbl-128ibm/s_fromfpl_main.c Normal file
View File

@@ -0,0 +1,62 @@
/* Round to integer type (C23 version). ldbl-128ibm version.
Copyright (C) 2016-2025 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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fenv.h>
#include <math.h>
#include <math_private.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#define FLOAT long double
#define PREFIX LDBL_
#define SUFFIX l
#define BIAS 0x3ff
#define MANT_DIG 53
#include <fromfp.h>
long double
FUNC (long double x, int round, unsigned int width)
{
width = fromfp_adjust_width (width);
long double rx = fromfp_round (x, round);
if (width == 0 || !isfinite (rx))
return fromfp_domain_error ();
double hi, lo;
uint64_t hx, lx;
ldbl_unpack (rx, &hi, &lo);
EXTRACT_WORDS64 (hx, hi);
EXTRACT_WORDS64 (lx, lo);
bool negative = (hx & 0x8000000000000000ULL) != 0;
bool lo_negative = (lx & 0x8000000000000000ULL) != 0;
hx &= 0x7fffffffffffffffULL;
lx &= 0x7fffffffffffffffULL;
int hi_exponent = hx >> (MANT_DIG - 1);
hi_exponent -= BIAS;
int exponent = hi_exponent;
hx &= ((1ULL << (MANT_DIG - 1)) - 1);
if (hx == 0 && lx != 0 && lo_negative != negative)
exponent--;
int max_exponent = fromfp_max_exponent (negative, width);
if (exponent > max_exponent
|| (!UNSIGNED && negative && exponent == max_exponent && (hx | lx) != 0))
return fromfp_domain_error ();
return fromfp_return (x, rx);
}

16
sysdeps/ieee754/ldbl-128ibm/s_fromfpxl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
weak_alias (__fromfpxl, fromfpxl)

16
sysdeps/ieee754/ldbl-128ibm/s_ufromfpl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
weak_alias (__ufromfpl, ufromfpl)

16
sysdeps/ieee754/ldbl-128ibm/s_ufromfpxl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
weak_alias (__ufromfpxl, ufromfpxl)

4
sysdeps/ieee754/ldbl-96/Makefile
View File

@@ -94,6 +94,8 @@ CFLAGS-s_fmull.c += -fno-builtin-f32mulf64x
CFLAGS-s_frexpl.c += -fno-builtin-frexpf64x
CFLAGS-s_compat_fromfpl.c += -fno-builtin-fromfpf64x
CFLAGS-s_compat_fromfpxl.c += -fno-builtin-fromfpxf64x
CFLAGS-s_fromfpl.c += -fno-builtin-fromfpf64x
CFLAGS-s_fromfpxl.c += -fno-builtin-fromfpxf64x
CFLAGS-s_fsqrtl.c += -fno-builtin-f32sqrtf64x
CFLAGS-s_fsubl.c += -fno-builtin-f32subf64x
CFLAGS-s_getpayloadl.c += -fno-builtin-getpayloadf64x
@@ -143,6 +145,8 @@ CFLAGS-s_totalordermagl.c += -fno-builtin-totalordermagf64x
CFLAGS-s_truncl.c += -fno-builtin-truncf64x
CFLAGS-s_compat_ufromfpl.c += -fno-builtin-ufromfpf64x
CFLAGS-s_compat_ufromfpxl.c += -fno-builtin-ufromfpxf64x
CFLAGS-s_ufromfpl.c += -fno-builtin-ufromfpf64x
CFLAGS-s_ufromfpxl.c += -fno-builtin-ufromfpxf64x
CFLAGS-s_y0l.c += -fno-builtin-y0f64x
CFLAGS-s_y1l.c += -fno-builtin-y1f64x
CFLAGS-s_ynl.c += -fno-builtin-ynf64x

16
sysdeps/ieee754/ldbl-96/s_compat_fromfpl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpl
#define FUNC __compat_fromfpl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__fromfp, fromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_fromfp, fromfp)
#endif

9
sysdeps/ieee754/ldbl-96/s_compat_fromfpl_main.c
View File

@@ -1,4 +1,4 @@
/* Round to integer type. ldbl-96 version.
/* Round to integer type (pre-C23 compat version). ldbl-96 version.
Copyright (C) 2016-2025 Free Software Foundation, Inc.
This file is part of the GNU C Library.
@@ -23,6 +23,8 @@
#include <libm-alias-ldouble.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#include <first-versions.h>
#define BIAS 0x3fff
#define MANT_DIG 64
@@ -33,9 +35,11 @@
# define RET_TYPE intmax_t
#endif
#include <compat_fromfp.h>
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# include <compat_fromfp.h>
RET_TYPE
attribute_compat_text_section
FUNC (long double x, int round, unsigned int width)
{
if (width > INTMAX_WIDTH)
@@ -83,3 +87,4 @@ FUNC (long double x, int round, unsigned int width)
return fromfp_round_and_return (negative, uret, half_bit, more_bits, round,
exponent, max_exponent, width);
}
#endif

16
sysdeps/ieee754/ldbl-96/s_compat_fromfpxl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxl
#define FUNC __compat_fromfpxl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__fromfpx, fromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_fromfpx, fromfpx)
#endif

16
sysdeps/ieee754/ldbl-96/s_compat_ufromfpl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpl
#define FUNC __compat_ufromfpl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__ufromfp, ufromfp)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_ufromfp, ufromfp)
#endif

16
sysdeps/ieee754/ldbl-96/s_compat_ufromfpxl.c
View File

@@ -1,5 +1,17 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxl
#define FUNC __compat_ufromfpxl
#include <s_compat_fromfpl_main.c>
libm_alias_ldouble (__ufromfpx, ufromfpx)
#if SHLIB_COMPAT (libm, GLIBC_2_25, GLIBC_2_43)
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
compat_symbol (libm, name, aliasname, \
CONCAT (FIRST_VERSION_libm_, aliasname))
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
libm_alias_ldouble (__compat_ufromfpx, ufromfpx)
#endif

16
sysdeps/ieee754/ldbl-96/s_fromfpl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 0
#define FUNC __fromfpl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__fromfp, fromfp)

58
sysdeps/ieee754/ldbl-96/s_fromfpl_main.c Normal file
View File

@@ -0,0 +1,58 @@
/* Round to integer type (C23 version). ldbl-96 version.
Copyright (C) 2016-2025 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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <fenv.h>
#include <math.h>
#include <math_private.h>
#include <libm-alias-ldouble.h>
#include <stdbool.h>
#include <stdint.h>
#include <shlib-compat.h>
#define FLOAT long double
#define PREFIX LDBL_
#define SUFFIX l
#define BIAS 0x3fff
#define MANT_DIG 64
#include <fromfp.h>
long double
FUNC (long double x, int round, unsigned int width)
{
width = fromfp_adjust_width (width);
long double rx = fromfp_round (x, round);
if (width == 0 || !isfinite (rx))
return fromfp_domain_error ();
uint16_t se;
uint32_t hx, lx;
GET_LDOUBLE_WORDS (se, hx, lx, rx);
bool negative = (se & 0x8000) != 0;
int exponent = se & 0x7fff;
exponent -= BIAS;
int max_exponent = fromfp_max_exponent (negative, width);
uint64_t ix = (((uint64_t) hx) << 32) | lx;
if (exponent > max_exponent
|| (!UNSIGNED
&& negative
&& exponent == max_exponent
&& ix != 0x8000000000000000ULL))
return fromfp_domain_error ();
return fromfp_return (x, rx);
}

16
sysdeps/ieee754/ldbl-96/s_fromfpxl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 0
#define INEXACT 1
#define FUNC __fromfpxl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__fromfpx, fromfpx)

16
sysdeps/ieee754/ldbl-96/s_ufromfpl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 0
#define FUNC __ufromfpl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__ufromfp, ufromfp)

16
sysdeps/ieee754/ldbl-96/s_ufromfpxl.c Normal file
View File

@@ -0,0 +1,16 @@
#define UNSIGNED 1
#define INEXACT 1
#define FUNC __ufromfpxl
#include <s_fromfpl_main.c>
#ifdef SHARED
# define CONCATX(x, y) x ## y
# define CONCAT(x, y) CONCATX (x, y)
# define UNIQUE_ALIAS(name) CONCAT (name, __COUNTER__)
# define do_symbol(orig_name, name, aliasname) \
strong_alias (orig_name, name) \
versioned_symbol (libm, name, aliasname, GLIBC_2_43)
# undef weak_alias
# define weak_alias(name, aliasname) \
do_symbol (name, UNIQUE_ALIAS (name), aliasname);
#endif
libm_alias_ldouble (__ufromfpx, ufromfpx)

2
sysdeps/ieee754/ldbl-opt/nldbl-fromfp.c
View File

@@ -18,7 +18,7 @@
#include "nldbl-compat.h"
intmax_t
double
attribute_hidden
fromfpl (double x, int round, unsigned int width)
{

2
sysdeps/ieee754/ldbl-opt/nldbl-fromfpx.c
View File

@@ -18,7 +18,7 @@
#include "nldbl-compat.h"
intmax_t
double
attribute_hidden
fromfpxl (double x, int round, unsigned int width)
{

2
sysdeps/ieee754/ldbl-opt/nldbl-ufromfp.c
View File

@@ -18,7 +18,7 @@
#include "nldbl-compat.h"
uintmax_t
double
attribute_hidden
ufromfpl (double x, int round, unsigned int width)
{

2
sysdeps/ieee754/ldbl-opt/nldbl-ufromfpx.c
View File

@@ -18,7 +18,7 @@
#include "nldbl-compat.h"
uintmax_t
double
attribute_hidden
ufromfpxl (double x, int round, unsigned int width)
{

32
sysdeps/mach/hurd/i386/libm.abilist
View File

@@ -1325,6 +1325,22 @@ GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fmod F
GLIBC_2.43 fmodf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf128 F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpf64x F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf128 F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxf64x F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -1336,6 +1352,22 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf128 F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpf64x F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf128 F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxf64x F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

32
sysdeps/mach/hurd/x86_64/libm.abilist
View File

@@ -1174,3 +1174,35 @@ GLIBC_2.42 rsqrtf32x F
GLIBC_2.42 rsqrtf64 F
GLIBC_2.42 rsqrtf64x F
GLIBC_2.42 rsqrtl F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf128 F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpf64x F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf128 F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxf64x F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf128 F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpf64x F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf128 F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxf64x F
GLIBC_2.43 ufromfpxl F

4
sysdeps/powerpc/powerpc64/le/fpu/multiarch/Makefile
View File

@@ -283,6 +283,8 @@ CFLAGS-s_fmulf128-ifunc.c += -fno-builtin-f32mulf64x
CFLAGS-s_frexpf128-ifunc.c += -fno-builtin-frexpf64x
CFLAGS-s_compat_fromfpf128-ifunc.c += -fno-builtin-fromfpf64x
CFLAGS-s_compat_fromfpxf128-ifunc.c += -fno-builtin-fromfpxf64x
CFLAGS-s_fromfpf128-ifunc.c += -fno-builtin-fromfpf64x
CFLAGS-s_fromfpxf128-ifunc.c += -fno-builtin-fromfpxf64x
CFLAGS-s_fsqrtf128-ifunc.c += -fno-builtin-f32sqrtf64x
CFLAGS-s_fsubf128-ifunc.c += -fno-builtin-f32subf64x
CFLAGS-s_getpayloadf128-ifunc.c += -fno-builtin-getpayloadf64x
@@ -332,6 +334,8 @@ CFLAGS-s_totalordermagf128-ifunc.c += -fno-builtin-totalordermagf64x
CFLAGS-s_truncf128-ifunc.c += -fno-builtin-truncf64x
CFLAGS-s_compat_ufromfpf128-ifunc.c += -fno-builtin-ufromfpf64x
CFLAGS-s_compat_ufromfpxf128-ifunc.c += -fno-builtin-ufromfpxf64x
CFLAGS-s_ufromfpf128-ifunc.c += -fno-builtin-ufromfpf64x
CFLAGS-s_ufromfpxf128-ifunc.c += -fno-builtin-ufromfpxf64x
CFLAGS-s_y0f128-ifunc.c += -fno-builtin-y0f64x
CFLAGS-s_y1f128-ifunc.c += -fno-builtin-y1f64x
CFLAGS-s_ynf128-ifunc.c += -fno-builtin-ynf64x

32
sysdeps/unix/sysv/linux/aarch64/libm.abilist
View File

@@ -1291,6 +1291,22 @@ GLIBC_2.43 asinf F
GLIBC_2.43 atan2f F
GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf128 F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpf64x F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf128 F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxf64x F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -1302,6 +1318,22 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf128 F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpf64x F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf128 F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxf64x F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

32
sysdeps/unix/sysv/linux/alpha/libm.abilist
View File

@@ -1450,6 +1450,22 @@ GLIBC_2.43 asinf F
GLIBC_2.43 atan2f F
GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf128 F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpf64x F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf128 F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxf64x F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -1461,6 +1477,22 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf128 F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpf64x F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf128 F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxf64x F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

24
sysdeps/unix/sysv/linux/arc/libm.abilist
View File

@@ -859,3 +859,27 @@ GLIBC_2.42 rsqrtf32 F
GLIBC_2.42 rsqrtf32x F
GLIBC_2.42 rsqrtf64 F
GLIBC_2.42 rsqrtl F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxl F

24
sysdeps/unix/sysv/linux/arm/be/libm.abilist
View File

@@ -956,6 +956,18 @@ GLIBC_2.43 asinf F
GLIBC_2.43 atan2f F
GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -967,6 +979,18 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

24
sysdeps/unix/sysv/linux/arm/le/libm.abilist
View File

@@ -956,6 +956,18 @@ GLIBC_2.43 asinf F
GLIBC_2.43 atan2f F
GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -967,6 +979,18 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

24
sysdeps/unix/sysv/linux/csky/libm.abilist
View File

@@ -925,3 +925,27 @@ GLIBC_2.42 rsqrtf32 F
GLIBC_2.42 rsqrtf32x F
GLIBC_2.42 rsqrtf64 F
GLIBC_2.42 rsqrtl F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxl F

24
sysdeps/unix/sysv/linux/hppa/libm.abilist
View File

@@ -956,6 +956,18 @@ GLIBC_2.43 asinf F
GLIBC_2.43 atan2f F
GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -967,6 +979,18 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

32
sysdeps/unix/sysv/linux/i386/libm.abilist
View File

@@ -1332,6 +1332,22 @@ GLIBC_2.43 atanhf F
GLIBC_2.43 coshf F
GLIBC_2.43 fmod F
GLIBC_2.43 fmodf F
GLIBC_2.43 fromfp F
GLIBC_2.43 fromfpf F
GLIBC_2.43 fromfpf128 F
GLIBC_2.43 fromfpf32 F
GLIBC_2.43 fromfpf32x F
GLIBC_2.43 fromfpf64 F
GLIBC_2.43 fromfpf64x F
GLIBC_2.43 fromfpl F
GLIBC_2.43 fromfpx F
GLIBC_2.43 fromfpxf F
GLIBC_2.43 fromfpxf128 F
GLIBC_2.43 fromfpxf32 F
GLIBC_2.43 fromfpxf32x F
GLIBC_2.43 fromfpxf64 F
GLIBC_2.43 fromfpxf64x F
GLIBC_2.43 fromfpxl F
GLIBC_2.43 j0f F
GLIBC_2.43 j1f F
GLIBC_2.43 jnf F
@@ -1343,6 +1359,22 @@ GLIBC_2.43 remainderf F
GLIBC_2.43 sinhf F
GLIBC_2.43 sqrtf F
GLIBC_2.43 tgammaf F
GLIBC_2.43 ufromfp F
GLIBC_2.43 ufromfpf F
GLIBC_2.43 ufromfpf128 F
GLIBC_2.43 ufromfpf32 F
GLIBC_2.43 ufromfpf32x F
GLIBC_2.43 ufromfpf64 F
GLIBC_2.43 ufromfpf64x F
GLIBC_2.43 ufromfpl F
GLIBC_2.43 ufromfpx F
GLIBC_2.43 ufromfpxf F
GLIBC_2.43 ufromfpxf128 F
GLIBC_2.43 ufromfpxf32 F
GLIBC_2.43 ufromfpxf32x F
GLIBC_2.43 ufromfpxf64 F
GLIBC_2.43 ufromfpxf64x F
GLIBC_2.43 ufromfpxl F
GLIBC_2.43 y0f F
GLIBC_2.43 y1f F
GLIBC_2.43 ynf F

Some files were not shown because too many files have changed in this diff Show More