mirror of
https://sourceware.org/git/glibc.git
synced 2025-08-07 06:43:00 +03:00
75ad83f564
C23 adds various <math.h> function families originally defined in TS 18661-4. Add the pown functions, which are like pow but with an integer exponent. That exponent has type long long int in C23; it was intmax_t in TS 18661-4, and as with other interfaces changed after their initial appearance in the TS, I don't think we need to support the original version of the interface. The test inputs are based on the subset of test inputs for pow that use integer exponents that fit in long long. As the first such template implementation that saves and restores the rounding mode internally (to avoid possible issues with directed rounding and intermediate overflows or underflows in the wrong rounding mode), support also needed to be added for using SET_RESTORE_ROUND* in such template function implementations. This required math-type-macros-float128.h to include <fenv_private.h>, so it can tell whether SET_RESTORE_ROUNDF128 is defined. In turn, the include order with <fenv_private.h> included before <math_private.h> broke loongarch builds, showing up that sysdeps/loongarch/math_private.h is really a fenv_private.h file (maybe implemented internally before the consistent split of those headers in 2018?) and needed to be renamed to fenv_private.h to avoid errors with duplicate macro definitions if <math_private.h> is included after <fenv_private.h>. The underlying implementation uses __ieee754_pow functions (called more than once in some cases, where the exponent does not fit in the floating type). I expect a custom implementation for a given format, that only handles integer exponents but handles larger exponents directly, could be faster and more accurate in some cases. I encourage searching for worst cases for ulps error for these implementations (necessarily non-exhaustively, given the size of the input space). Tested for x86_64 and x86, and with build-many-glibcs.py.
249 lines
7.2 KiB
C
249 lines
7.2 KiB
C
/* Internal math stuff.
|
|
Copyright (C) 2022-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/>. */
|
|
|
|
#ifndef LOONGARCH_FENV_PRIVATE_H
|
|
#define LOONGARCH_FENV_PRIVATE_H 1
|
|
|
|
/* Inline functions to speed up the math library implementation. The
|
|
default versions of these routines are in generic/fenv_private.h
|
|
and call fesetround, feholdexcept, etc. These routines use inlined
|
|
code instead. */
|
|
|
|
#ifdef __loongarch_hard_float
|
|
|
|
#include <fenv.h>
|
|
#include <fenv_libc.h>
|
|
#include <fpu_control.h>
|
|
|
|
#define _FPU_MASK_ALL \
|
|
(_FPU_MASK_V | _FPU_MASK_Z | _FPU_MASK_O | _FPU_MASK_U | _FPU_MASK_I \
|
|
| FE_ALL_EXCEPT)
|
|
|
|
static __always_inline void
|
|
libc_feholdexcept_loongarch (fenv_t *envp)
|
|
{
|
|
fpu_control_t cw;
|
|
|
|
/* Save the current state. */
|
|
_FPU_GETCW (cw);
|
|
envp->__fp_control_register = cw;
|
|
|
|
/* Clear all exception enable bits and flags. */
|
|
cw &= ~(_FPU_MASK_ALL);
|
|
_FPU_SETCW (cw);
|
|
}
|
|
#define libc_feholdexcept libc_feholdexcept_loongarch
|
|
#define libc_feholdexceptf libc_feholdexcept_loongarch
|
|
#define libc_feholdexceptl libc_feholdexcept_loongarch
|
|
|
|
static __always_inline void
|
|
libc_fesetround_loongarch (int round)
|
|
{
|
|
fpu_control_t cw;
|
|
|
|
/* Get current state. */
|
|
_FPU_GETCW (cw);
|
|
|
|
/* Set rounding bits. */
|
|
cw &= ~_FPU_RC_MASK;
|
|
cw |= round;
|
|
|
|
/* Set new state. */
|
|
_FPU_SETCW (cw);
|
|
}
|
|
#define libc_fesetround libc_fesetround_loongarch
|
|
#define libc_fesetroundf libc_fesetround_loongarch
|
|
#define libc_fesetroundl libc_fesetround_loongarch
|
|
|
|
static __always_inline void
|
|
libc_feholdexcept_setround_loongarch (fenv_t *envp, int round)
|
|
{
|
|
fpu_control_t cw;
|
|
|
|
/* Save the current state. */
|
|
_FPU_GETCW (cw);
|
|
envp->__fp_control_register = cw;
|
|
|
|
/* Clear all exception enable bits and flags. */
|
|
cw &= ~(_FPU_MASK_ALL);
|
|
|
|
/* Set rounding bits. */
|
|
cw &= ~_FPU_RC_MASK;
|
|
cw |= round;
|
|
|
|
/* Set new state. */
|
|
_FPU_SETCW (cw);
|
|
}
|
|
#define libc_feholdexcept_setround libc_feholdexcept_setround_loongarch
|
|
#define libc_feholdexcept_setroundf libc_feholdexcept_setround_loongarch
|
|
#define libc_feholdexcept_setroundl libc_feholdexcept_setround_loongarch
|
|
|
|
#define libc_feholdsetround libc_feholdexcept_setround_loongarch
|
|
#define libc_feholdsetroundf libc_feholdexcept_setround_loongarch
|
|
#define libc_feholdsetroundl libc_feholdexcept_setround_loongarch
|
|
|
|
static __always_inline void
|
|
libc_fesetenv_loongarch (fenv_t *envp)
|
|
{
|
|
fpu_control_t cw __attribute__ ((unused));
|
|
|
|
/* Read current state to flush fpu pipeline. */
|
|
_FPU_GETCW (cw);
|
|
|
|
_FPU_SETCW (envp->__fp_control_register);
|
|
}
|
|
#define libc_fesetenv libc_fesetenv_loongarch
|
|
#define libc_fesetenvf libc_fesetenv_loongarch
|
|
#define libc_fesetenvl libc_fesetenv_loongarch
|
|
|
|
static __always_inline int
|
|
libc_feupdateenv_test_loongarch (fenv_t *envp, int excepts)
|
|
{
|
|
/* int ret = fetestexcept (excepts); feupdateenv (envp); return ret; */
|
|
int cw, temp;
|
|
|
|
/* Get current control word. */
|
|
_FPU_GETCW (cw);
|
|
|
|
/* Set flag bits (which are accumulative), and *also* set the
|
|
cause bits. The setting of the cause bits is what actually causes
|
|
the hardware to generate the exception, if the corresponding enable
|
|
bit is set as well. */
|
|
temp = cw & FE_ALL_EXCEPT;
|
|
temp |= envp->__fp_control_register | (temp << CAUSE_SHIFT);
|
|
|
|
/* Set new state. */
|
|
_FPU_SETCW (temp);
|
|
|
|
return cw & excepts & FE_ALL_EXCEPT;
|
|
}
|
|
#define libc_feupdateenv_test libc_feupdateenv_test_loongarch
|
|
#define libc_feupdateenv_testf libc_feupdateenv_test_loongarch
|
|
#define libc_feupdateenv_testl libc_feupdateenv_test_loongarch
|
|
|
|
static __always_inline void
|
|
libc_feupdateenv_loongarch (fenv_t *envp)
|
|
{
|
|
libc_feupdateenv_test_loongarch (envp, 0);
|
|
}
|
|
#define libc_feupdateenv libc_feupdateenv_loongarch
|
|
#define libc_feupdateenvf libc_feupdateenv_loongarch
|
|
#define libc_feupdateenvl libc_feupdateenv_loongarch
|
|
|
|
#define libc_feresetround libc_feupdateenv_loongarch
|
|
#define libc_feresetroundf libc_feupdateenv_loongarch
|
|
#define libc_feresetroundl libc_feupdateenv_loongarch
|
|
|
|
static __always_inline int
|
|
libc_fetestexcept_loongarch (int excepts)
|
|
{
|
|
int cw;
|
|
|
|
/* Get current control word. */
|
|
_FPU_GETCW (cw);
|
|
|
|
return cw & excepts & FE_ALL_EXCEPT;
|
|
}
|
|
#define libc_fetestexcept libc_fetestexcept_loongarch
|
|
#define libc_fetestexceptf libc_fetestexcept_loongarch
|
|
#define libc_fetestexceptl libc_fetestexcept_loongarch
|
|
|
|
/* Enable support for rounding mode context. */
|
|
#define HAVE_RM_CTX 1
|
|
|
|
static __always_inline void
|
|
libc_feholdexcept_setround_loongarch_ctx (struct rm_ctx *ctx, int round)
|
|
{
|
|
fpu_control_t old, new;
|
|
|
|
/* Save the current state. */
|
|
_FPU_GETCW (old);
|
|
ctx->env.__fp_control_register = old;
|
|
|
|
/* Clear all exception enable bits and flags. */
|
|
new = old & ~(_FPU_MASK_ALL);
|
|
|
|
/* Set rounding bits. */
|
|
new = (new & ~_FPU_RC_MASK) | round;
|
|
|
|
if (__glibc_unlikely (new != old))
|
|
{
|
|
_FPU_SETCW (new);
|
|
ctx->updated_status = true;
|
|
}
|
|
else
|
|
ctx->updated_status = false;
|
|
}
|
|
#define libc_feholdexcept_setround_ctx libc_feholdexcept_setround_loongarch_ctx
|
|
#define libc_feholdexcept_setroundf_ctx \
|
|
libc_feholdexcept_setround_loongarch_ctx
|
|
#define libc_feholdexcept_setroundl_ctx \
|
|
libc_feholdexcept_setround_loongarch_ctx
|
|
|
|
static __always_inline void
|
|
libc_fesetenv_loongarch_ctx (struct rm_ctx *ctx)
|
|
{
|
|
libc_fesetenv_loongarch (&ctx->env);
|
|
}
|
|
#define libc_fesetenv_ctx libc_fesetenv_loongarch_ctx
|
|
#define libc_fesetenvf_ctx libc_fesetenv_loongarch_ctx
|
|
#define libc_fesetenvl_ctx libc_fesetenv_loongarch_ctx
|
|
|
|
static __always_inline void
|
|
libc_feupdateenv_loongarch_ctx (struct rm_ctx *ctx)
|
|
{
|
|
if (__glibc_unlikely (ctx->updated_status))
|
|
libc_feupdateenv_test_loongarch (&ctx->env, 0);
|
|
}
|
|
#define libc_feupdateenv_ctx libc_feupdateenv_loongarch_ctx
|
|
#define libc_feupdateenvf_ctx libc_feupdateenv_loongarch_ctx
|
|
#define libc_feupdateenvl_ctx libc_feupdateenv_loongarch_ctx
|
|
#define libc_feresetround_ctx libc_feupdateenv_loongarch_ctx
|
|
#define libc_feresetroundf_ctx libc_feupdateenv_loongarch_ctx
|
|
#define libc_feresetroundl_ctx libc_feupdateenv_loongarch_ctx
|
|
|
|
static __always_inline void
|
|
libc_feholdsetround_loongarch_ctx (struct rm_ctx *ctx, int round)
|
|
{
|
|
fpu_control_t old, new;
|
|
|
|
/* Save the current state. */
|
|
_FPU_GETCW (old);
|
|
ctx->env.__fp_control_register = old;
|
|
|
|
/* Set rounding bits. */
|
|
new = (old & ~_FPU_RC_MASK) | round;
|
|
|
|
if (__glibc_unlikely (new != old))
|
|
{
|
|
_FPU_SETCW (new);
|
|
ctx->updated_status = true;
|
|
}
|
|
else
|
|
ctx->updated_status = false;
|
|
}
|
|
#define libc_feholdsetround_ctx libc_feholdsetround_loongarch_ctx
|
|
#define libc_feholdsetroundf_ctx libc_feholdsetround_loongarch_ctx
|
|
#define libc_feholdsetroundl_ctx libc_feholdsetround_loongarch_ctx
|
|
|
|
#endif
|
|
|
|
#include_next <fenv_private.h>
|
|
|
|
#endif
|