mirror of
https://sourceware.org/git/glibc.git
synced 2025-07-29 11:41:21 +03:00
Split fenv_private.h out of math_private.h more consistently.
On some architectures, the parts of math_private.h relating to the floating-point environment are in a separate file fenv_private.h included from math_private.h. As this is purely an architecture-specific convention used by several architectures, however, all such architectures still need their own math_private.h, even if it has nothing to do beyond #include <fenv_private.h> and peculiarity of including the i386 file directly instead of having a shared file in sysdeps/x86. This patch makes the fenv_private.h name an architecture-independent convention in glibc. The include of fenv_private.h from math_private.h becomes architecture-independent (until callers are updated to include fenv_private.h directly so the include from math_private.h is no longer needed). Some architecture math_private.h headers are removed if no longer needed, or renamed to fenv_private.h if all they define belongs in that header; architecture fenv_private.h headers now do require #include_next <fenv_private.h>. The i386 fenv_private.h file moves to sysdeps/x86/fpu/ to reflect how it is actually shared with x86_64. The generic math_private.h gets a new include of <stdbool.h>, as needed for bool in some prototypes in that header (previously that was indirectly included via include/fenv.h, which now only gets included too late in math_private.h, after those prototypes). Tested for x86_64 and x86, and tested with build-many-glibcs.py that installed stripped shared libraries are unchanged by the patch. * sysdeps/aarch64/fpu/fenv_private.h: New file. Based on .... * sysdeps/aarch64/fpu/math_private.h: ... this file. All contents moved to fenv_private.h except for ... (TOINT_INTRINSICS): Kept in math_private.h. (roundtoint): Likewise. (converttoint): Likewise. * sysdeps/arm/fenv_private.h: Change multiple-include guard to [ARM_FENV_PRIVATE_H]. Include next <fenv_private.h>. * sysdeps/arm/math_private.h: Remove. * sysdeps/generic/fenv_private.h: New file. Contents moved from .... * sysdeps/generic/math_private.h: ... this file. Include <stdbool.h>. Do not include <fenv.h> or <get-rounding-mode.h>. Include <fenv_private.h>. Remove functions and macros moved to fenv_private.h. * sysdeps/i386/fpu/math_private.h: Remove. * sysdeps/mips/math_private.h: Move to .... * sysdeps/mips/fpu/fenv_private.h: ... here. Change multiple-include guard to [MIPS_FENV_PRIVATE_H]. Remove [__mips_hard_float] conditional. Include next <fenv_private.h>. * sysdeps/powerpc/fpu/fenv_private.h: Change multiple-include guard to [POWERPC_FENV_PRIVATE_H]. Include next <fenv_private.h>. * sysdeps/powerpc/fpu/math_private.h: Do not include <fenv_private.h>. * sysdeps/riscv/rvf/math_private.h: Move to .... * sysdeps/riscv/rvf/fenv_private.h: ... here. Change multiple-include guard to [RISCV_FENV_PRIVATE_H]. Include next <fenv_private.h>. * sysdeps/sparc/fpu/fenv_private.h: Change multiple-include guard to [SPARC_FENV_PRIVATE_H]. Include next <fenv_private.h>. * sysdeps/sparc/fpu/math_private.h: Remove. * sysdeps/i386/fpu/fenv_private.h: Move to .... * sysdeps/x86/fpu/fenv_private.h: ... here. Change multiple-include guard to [X86_FENV_PRIVATE_H]. Include next <fenv_private.h>. * sysdeps/x86_64/fpu/math_private.h: Do not include <sysdeps/i386/fpu/fenv_private.h>.
This commit is contained in:
Joseph Myers
@ -17,10 +17,9 @@
|
||||
#define _MATH_PRIVATE_H_
|
||||
|
||||
#include <endian.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
#include <fenv.h>
|
||||
#include <get-rounding-mode.h>
|
||||
|
||||
/* Gather machine dependent _Floatn support. */
|
||||
#include <bits/floatn.h>
|
||||
@ -262,396 +261,6 @@ extern double __mpsin (double __x, double __dx, bool __range_reduce);
|
||||
extern double __mpcos (double __x, double __dx, bool __range_reduce);
|
||||
extern void __docos (double __x, double __dx, double __v[]);
|
||||
|
||||
/* The standards only specify one variant of the fenv.h interfaces.
|
||||
But at least for some architectures we can be more efficient if we
|
||||
know what operations are going to be performed. Therefore we
|
||||
define additional interfaces. By default they refer to the normal
|
||||
interfaces. */
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feholdexcept (fenv_t *e)
|
||||
{
|
||||
(void) __feholdexcept (e);
|
||||
}
|
||||
|
||||
#ifndef libc_feholdexcept
|
||||
# define libc_feholdexcept default_libc_feholdexcept
|
||||
#endif
|
||||
#ifndef libc_feholdexceptf
|
||||
# define libc_feholdexceptf default_libc_feholdexcept
|
||||
#endif
|
||||
#ifndef libc_feholdexceptl
|
||||
# define libc_feholdexceptl default_libc_feholdexcept
|
||||
#endif
|
||||
|
||||
static __always_inline void
|
||||
default_libc_fesetround (int r)
|
||||
{
|
||||
(void) __fesetround (r);
|
||||
}
|
||||
|
||||
#ifndef libc_fesetround
|
||||
# define libc_fesetround default_libc_fesetround
|
||||
#endif
|
||||
#ifndef libc_fesetroundf
|
||||
# define libc_fesetroundf default_libc_fesetround
|
||||
#endif
|
||||
#ifndef libc_fesetroundl
|
||||
# define libc_fesetroundl default_libc_fesetround
|
||||
#endif
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feholdexcept_setround (fenv_t *e, int r)
|
||||
{
|
||||
__feholdexcept (e);
|
||||
__fesetround (r);
|
||||
}
|
||||
|
||||
#ifndef libc_feholdexcept_setround
|
||||
# define libc_feholdexcept_setround default_libc_feholdexcept_setround
|
||||
#endif
|
||||
#ifndef libc_feholdexcept_setroundf
|
||||
# define libc_feholdexcept_setroundf default_libc_feholdexcept_setround
|
||||
#endif
|
||||
#ifndef libc_feholdexcept_setroundl
|
||||
# define libc_feholdexcept_setroundl default_libc_feholdexcept_setround
|
||||
#endif
|
||||
|
||||
#ifndef libc_feholdsetround_53bit
|
||||
# define libc_feholdsetround_53bit libc_feholdsetround
|
||||
#endif
|
||||
|
||||
#ifndef libc_fetestexcept
|
||||
# define libc_fetestexcept fetestexcept
|
||||
#endif
|
||||
#ifndef libc_fetestexceptf
|
||||
# define libc_fetestexceptf fetestexcept
|
||||
#endif
|
||||
#ifndef libc_fetestexceptl
|
||||
# define libc_fetestexceptl fetestexcept
|
||||
#endif
|
||||
|
||||
static __always_inline void
|
||||
default_libc_fesetenv (fenv_t *e)
|
||||
{
|
||||
(void) __fesetenv (e);
|
||||
}
|
||||
|
||||
#ifndef libc_fesetenv
|
||||
# define libc_fesetenv default_libc_fesetenv
|
||||
#endif
|
||||
#ifndef libc_fesetenvf
|
||||
# define libc_fesetenvf default_libc_fesetenv
|
||||
#endif
|
||||
#ifndef libc_fesetenvl
|
||||
# define libc_fesetenvl default_libc_fesetenv
|
||||
#endif
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feupdateenv (fenv_t *e)
|
||||
{
|
||||
(void) __feupdateenv (e);
|
||||
}
|
||||
|
||||
#ifndef libc_feupdateenv
|
||||
# define libc_feupdateenv default_libc_feupdateenv
|
||||
#endif
|
||||
#ifndef libc_feupdateenvf
|
||||
# define libc_feupdateenvf default_libc_feupdateenv
|
||||
#endif
|
||||
#ifndef libc_feupdateenvl
|
||||
# define libc_feupdateenvl default_libc_feupdateenv
|
||||
#endif
|
||||
|
||||
#ifndef libc_feresetround_53bit
|
||||
# define libc_feresetround_53bit libc_feresetround
|
||||
#endif
|
||||
|
||||
static __always_inline int
|
||||
default_libc_feupdateenv_test (fenv_t *e, int ex)
|
||||
{
|
||||
int ret = fetestexcept (ex);
|
||||
__feupdateenv (e);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifndef libc_feupdateenv_test
|
||||
# define libc_feupdateenv_test default_libc_feupdateenv_test
|
||||
#endif
|
||||
#ifndef libc_feupdateenv_testf
|
||||
# define libc_feupdateenv_testf default_libc_feupdateenv_test
|
||||
#endif
|
||||
#ifndef libc_feupdateenv_testl
|
||||
# define libc_feupdateenv_testl default_libc_feupdateenv_test
|
||||
#endif
|
||||
|
||||
/* Save and set the rounding mode. The use of fenv_t to store the old mode
|
||||
allows a target-specific version of this function to avoid converting the
|
||||
rounding mode from the fpu format. By default we have no choice but to
|
||||
manipulate the entire env. */
|
||||
|
||||
#ifndef libc_feholdsetround
|
||||
# define libc_feholdsetround libc_feholdexcept_setround
|
||||
#endif
|
||||
#ifndef libc_feholdsetroundf
|
||||
# define libc_feholdsetroundf libc_feholdexcept_setroundf
|
||||
#endif
|
||||
#ifndef libc_feholdsetroundl
|
||||
# define libc_feholdsetroundl libc_feholdexcept_setroundl
|
||||
#endif
|
||||
|
||||
/* ... and the reverse. */
|
||||
|
||||
#ifndef libc_feresetround
|
||||
# define libc_feresetround libc_feupdateenv
|
||||
#endif
|
||||
#ifndef libc_feresetroundf
|
||||
# define libc_feresetroundf libc_feupdateenvf
|
||||
#endif
|
||||
#ifndef libc_feresetroundl
|
||||
# define libc_feresetroundl libc_feupdateenvl
|
||||
#endif
|
||||
|
||||
/* ... and a version that also discards exceptions. */
|
||||
|
||||
#ifndef libc_feresetround_noex
|
||||
# define libc_feresetround_noex libc_fesetenv
|
||||
#endif
|
||||
#ifndef libc_feresetround_noexf
|
||||
# define libc_feresetround_noexf libc_fesetenvf
|
||||
#endif
|
||||
#ifndef libc_feresetround_noexl
|
||||
# define libc_feresetround_noexl libc_fesetenvl
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_RM_CTX
|
||||
# define HAVE_RM_CTX 0
|
||||
#endif
|
||||
|
||||
|
||||
/* Default implementation using standard fenv functions.
|
||||
Avoid unnecessary rounding mode changes by first checking the
|
||||
current rounding mode. Note the use of __glibc_unlikely is
|
||||
important for performance. */
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feholdsetround_ctx (struct rm_ctx *ctx, int round)
|
||||
{
|
||||
ctx->updated_status = false;
|
||||
|
||||
/* Update rounding mode only if different. */
|
||||
if (__glibc_unlikely (round != get_rounding_mode ()))
|
||||
{
|
||||
ctx->updated_status = true;
|
||||
__fegetenv (&ctx->env);
|
||||
__fesetround (round);
|
||||
}
|
||||
}
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feresetround_ctx (struct rm_ctx *ctx)
|
||||
{
|
||||
/* Restore the rounding mode if updated. */
|
||||
if (__glibc_unlikely (ctx->updated_status))
|
||||
__feupdateenv (&ctx->env);
|
||||
}
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feholdsetround_noex_ctx (struct rm_ctx *ctx, int round)
|
||||
{
|
||||
/* Save exception flags and rounding mode, and disable exception
|
||||
traps. */
|
||||
__feholdexcept (&ctx->env);
|
||||
|
||||
/* Update rounding mode only if different. */
|
||||
if (__glibc_unlikely (round != get_rounding_mode ()))
|
||||
__fesetround (round);
|
||||
}
|
||||
|
||||
static __always_inline void
|
||||
default_libc_feresetround_noex_ctx (struct rm_ctx *ctx)
|
||||
{
|
||||
/* Restore exception flags and rounding mode. */
|
||||
__fesetenv (&ctx->env);
|
||||
}
|
||||
|
||||
#if HAVE_RM_CTX
|
||||
/* Set/Restore Rounding Modes only when necessary. If defined, these functions
|
||||
set/restore floating point state only if the state needed within the lexical
|
||||
block is different from the current state. This saves a lot of time when
|
||||
the floating point unit is much slower than the fixed point units. */
|
||||
|
||||
# ifndef libc_feholdsetround_noex_ctx
|
||||
# define libc_feholdsetround_noex_ctx libc_feholdsetround_ctx
|
||||
# endif
|
||||
# ifndef libc_feholdsetround_noexf_ctx
|
||||
# define libc_feholdsetround_noexf_ctx libc_feholdsetroundf_ctx
|
||||
# endif
|
||||
# ifndef libc_feholdsetround_noexl_ctx
|
||||
# define libc_feholdsetround_noexl_ctx libc_feholdsetroundl_ctx
|
||||
# endif
|
||||
|
||||
# ifndef libc_feresetround_noex_ctx
|
||||
# define libc_feresetround_noex_ctx libc_fesetenv_ctx
|
||||
# endif
|
||||
# ifndef libc_feresetround_noexf_ctx
|
||||
# define libc_feresetround_noexf_ctx libc_fesetenvf_ctx
|
||||
# endif
|
||||
# ifndef libc_feresetround_noexl_ctx
|
||||
# define libc_feresetround_noexl_ctx libc_fesetenvl_ctx
|
||||
# endif
|
||||
|
||||
#else
|
||||
|
||||
# define libc_feholdsetround_ctx default_libc_feholdsetround_ctx
|
||||
# define libc_feresetround_ctx default_libc_feresetround_ctx
|
||||
# define libc_feholdsetround_noex_ctx default_libc_feholdsetround_noex_ctx
|
||||
# define libc_feresetround_noex_ctx default_libc_feresetround_noex_ctx
|
||||
|
||||
# define libc_feholdsetroundf_ctx libc_feholdsetround_ctx
|
||||
# define libc_feholdsetroundl_ctx libc_feholdsetround_ctx
|
||||
# define libc_feresetroundf_ctx libc_feresetround_ctx
|
||||
# define libc_feresetroundl_ctx libc_feresetround_ctx
|
||||
|
||||
# define libc_feholdsetround_noexf_ctx libc_feholdsetround_noex_ctx
|
||||
# define libc_feholdsetround_noexl_ctx libc_feholdsetround_noex_ctx
|
||||
# define libc_feresetround_noexf_ctx libc_feresetround_noex_ctx
|
||||
# define libc_feresetround_noexl_ctx libc_feresetround_noex_ctx
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef libc_feholdsetround_53bit_ctx
|
||||
# define libc_feholdsetround_53bit_ctx libc_feholdsetround_ctx
|
||||
#endif
|
||||
#ifndef libc_feresetround_53bit_ctx
|
||||
# define libc_feresetround_53bit_ctx libc_feresetround_ctx
|
||||
#endif
|
||||
|
||||
#define SET_RESTORE_ROUND_GENERIC(RM,ROUNDFUNC,CLEANUPFUNC) \
|
||||
struct rm_ctx ctx __attribute__((cleanup (CLEANUPFUNC ## _ctx))); \
|
||||
ROUNDFUNC ## _ctx (&ctx, (RM))
|
||||
|
||||
/* Set the rounding mode within a lexical block. Restore the rounding mode to
|
||||
the value at the start of the block. The exception mode must be preserved.
|
||||
Exceptions raised within the block must be set in the exception flags.
|
||||
Non-stop mode may be enabled inside the block. */
|
||||
|
||||
#define SET_RESTORE_ROUND(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetround, libc_feresetround)
|
||||
#define SET_RESTORE_ROUNDF(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetroundf, libc_feresetroundf)
|
||||
#define SET_RESTORE_ROUNDL(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetroundl, libc_feresetroundl)
|
||||
|
||||
/* Set the rounding mode within a lexical block. Restore the rounding mode to
|
||||
the value at the start of the block. The exception mode must be preserved.
|
||||
Exceptions raised within the block must be discarded, and exception flags
|
||||
are restored to the value at the start of the block.
|
||||
Non-stop mode must be enabled inside the block. */
|
||||
|
||||
#define SET_RESTORE_ROUND_NOEX(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetround_noex, \
|
||||
libc_feresetround_noex)
|
||||
#define SET_RESTORE_ROUND_NOEXF(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetround_noexf, \
|
||||
libc_feresetround_noexf)
|
||||
#define SET_RESTORE_ROUND_NOEXL(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetround_noexl, \
|
||||
libc_feresetround_noexl)
|
||||
|
||||
/* Like SET_RESTORE_ROUND, but also set rounding precision to 53 bits. */
|
||||
#define SET_RESTORE_ROUND_53BIT(RM) \
|
||||
SET_RESTORE_ROUND_GENERIC (RM, libc_feholdsetround_53bit, \
|
||||
libc_feresetround_53bit)
|
||||
|
||||
/* When no floating-point exceptions are defined in <fenv.h>, make
|
||||
feraiseexcept ignore its argument so that unconditional
|
||||
feraiseexcept calls do not cause errors for undefined exceptions.
|
||||
Define it to expand to a void expression so that any calls testing
|
||||
the result of feraiseexcept do produce errors. */
|
||||
#if FE_ALL_EXCEPT == 0
|
||||
# define feraiseexcept(excepts) ((void) 0)
|
||||
# define __feraiseexcept(excepts) ((void) 0)
|
||||
#endif
|
||||
|
||||
/* Similarly, most <fenv.h> functions have trivial implementations in
|
||||
the absence of support for floating-point exceptions and rounding
|
||||
modes. */
|
||||
|
||||
#if !FE_HAVE_ROUNDING_MODES
|
||||
# if FE_ALL_EXCEPT == 0
|
||||
extern inline int
|
||||
fegetenv (fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
__fegetenv (fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
feholdexcept (fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
__feholdexcept (fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
fesetenv (const fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
__fesetenv (const fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
feupdateenv (const fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
__feupdateenv (const fenv_t *__e)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
# endif
|
||||
|
||||
extern inline int
|
||||
fegetround (void)
|
||||
{
|
||||
return FE_TONEAREST;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
__fegetround (void)
|
||||
{
|
||||
return FE_TONEAREST;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
fesetround (int __d)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern inline int
|
||||
__fesetround (int __d)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
#include <fenv_private.h>
|
||||
|
||||
#endif /* _MATH_PRIVATE_H_ */
|
||||
|
||||
Reference in New Issue
Block a user