mirror of
https://sourceware.org/git/glibc.git
synced 2025-11-30 11:41:39 +03:00
1f79bc4838
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.
118 lines
3.5 KiB
C
118 lines
3.5 KiB
C
/* 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;
|
|
}
|