diff --git a/lib/msun/aarch64/fenv.c b/lib/msun/aarch64/fenv.c index 5d626f66516f..a428a9d8a271 100644 --- a/lib/msun/aarch64/fenv.c +++ b/lib/msun/aarch64/fenv.c @@ -1,105 +1,100 @@ /*- * Copyright (c) 2004 David Schultz * Copyright (c) 2013 Andrew Turner * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ -#define __fenv_static #include "fenv.h" /* * Hopefully the system ID byte is immutable, so it's valid to use * this as a default environment. */ const fenv_t __fe_dfl_env = 0; -#ifdef __GNUC_GNU_INLINE__ -#error "This file must be compiled with C99 'inline' semantics" -#endif - int (feclearexcept)(int excepts) { return (__feclearexcept_int(excepts)); } int (fegetexceptflag)(fexcept_t *flagp, int excepts) { return (__fegetexceptflag_int(flagp, excepts)); } int (fesetexceptflag)(const fexcept_t *flagp, int excepts) { return (__fesetexceptflag_int(flagp, excepts)); } int (feraiseexcept)(int excepts) { return (__feraiseexcept_int(excepts)); } int (fetestexcept)(int excepts) { return (__fetestexcept_int(excepts)); } int (fegetround)(void) { return (__fegetround_int()); } int (fesetround)(int round) { return (__fesetround_int(round)); } int (fegetenv)(fenv_t *envp) { return (__fegetenv_int(envp)); } int (feholdexcept)(fenv_t *envp) { return (__feholdexcept_int(envp)); } int (fesetenv)(const fenv_t *envp) { return (__fesetenv_int(envp)); } int (feupdateenv)(const fenv_t *envp) { return (__feupdateenv_int(envp)); } diff --git a/lib/msun/amd64/fenv.c b/lib/msun/amd64/fenv.c index 5dd122cf457c..fe9ecfff3b83 100644 --- a/lib/msun/amd64/fenv.c +++ b/lib/msun/amd64/fenv.c @@ -1,190 +1,185 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2004-2005 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include -#define __fenv_static #include "fenv.h" -#ifdef __GNUC_GNU_INLINE__ -#error "This file must be compiled with C99 'inline' semantics" -#endif - const fenv_t __fe_dfl_env = { { 0xffff0000 | __INITIAL_FPUCW__, 0xffff0000, 0xffffffff, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff } }, __INITIAL_MXCSR__ }; int (feclearexcept)(int excepts) { return (__feclearexcept_int(excepts)); } int (fegetexceptflag)(fexcept_t *flagp, int excepts) { return (__fegetexceptflag_int(flagp, excepts)); } int fesetexceptflag(const fexcept_t *flagp, int excepts) { fenv_t env; __fnstenv(&env.__x87); env.__x87.__status &= ~excepts; env.__x87.__status |= *flagp & excepts; __fldenv(&env.__x87); __stmxcsr(&env.__mxcsr); env.__mxcsr &= ~excepts; env.__mxcsr |= *flagp & excepts; __ldmxcsr(&env.__mxcsr); return (0); } int feraiseexcept(int excepts) { fexcept_t ex = excepts; fesetexceptflag(&ex, excepts); __fwait(); return (0); } int (fetestexcept)(int excepts) { return (__fetestexcept_int(excepts)); } int (fegetround)(void) { return (__fegetround_int()); } int (fesetround)(int round) { return (__fesetround_int(round)); } int fegetenv(fenv_t *envp) { __fnstenv(&envp->__x87); __stmxcsr(&envp->__mxcsr); /* * fnstenv masks all exceptions, so we need to restore the * control word to avoid this side effect. */ __fldcw(&envp->__x87.__control); return (0); } int feholdexcept(fenv_t *envp) { __uint32_t mxcsr; __stmxcsr(&mxcsr); __fnstenv(&envp->__x87); __fnclex(); envp->__mxcsr = mxcsr; mxcsr &= ~FE_ALL_EXCEPT; mxcsr |= FE_ALL_EXCEPT << _SSE_EMASK_SHIFT; __ldmxcsr(&mxcsr); return (0); } int (fesetenv)(const fenv_t *envp) { return (__fesetenv_int(envp)); } int feupdateenv(const fenv_t *envp) { __uint32_t mxcsr; __uint16_t status; __fnstsw(&status); __stmxcsr(&mxcsr); fesetenv(envp); feraiseexcept((mxcsr | status) & FE_ALL_EXCEPT); return (0); } int __feenableexcept(int mask) { __uint32_t mxcsr, omask; __uint16_t control; mask &= FE_ALL_EXCEPT; __fnstcw(&control); __stmxcsr(&mxcsr); omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control &= ~mask; __fldcw(&control); mxcsr &= ~(mask << _SSE_EMASK_SHIFT); __ldmxcsr(&mxcsr); return (omask); } int __fedisableexcept(int mask) { __uint32_t mxcsr, omask; __uint16_t control; mask &= FE_ALL_EXCEPT; __fnstcw(&control); __stmxcsr(&mxcsr); omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control |= mask; __fldcw(&control); mxcsr |= mask << _SSE_EMASK_SHIFT; __ldmxcsr(&mxcsr); return (omask); } __weak_reference(__feenableexcept, feenableexcept); __weak_reference(__fedisableexcept, fedisableexcept); diff --git a/lib/msun/arm/fenv.c b/lib/msun/arm/fenv.c index 620a05d51b90..2cf5bbdea28f 100644 --- a/lib/msun/arm/fenv.c +++ b/lib/msun/arm/fenv.c @@ -1,395 +1,390 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2004 David Schultz * Copyright (c) 2013 Andrew Turner * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ -#define __fenv_static #include "fenv.h" #include /* When SOFTFP_ABI is defined we are using the softfp ABI. */ #if defined(__VFP_FP__) && !defined(__ARM_PCS_VFP) #define SOFTFP_ABI #endif #ifndef FENV_MANGLE /* * Hopefully the system ID byte is immutable, so it's valid to use * this as a default environment. */ const fenv_t __fe_dfl_env = 0; #endif /* If this is a non-mangled softfp version special processing is required */ #if defined(FENV_MANGLE) || !defined(SOFTFP_ABI) /* * The following macros map between the softfloat emulator's flags and * the hardware's FPSR. The hardware this file was written for doesn't * have rounding control bits, so we stick those in the system ID byte. */ #ifndef __ARM_PCS_VFP #define __set_env(env, flags, mask, rnd) env = ((flags) \ | (mask)<<_FPUSW_SHIFT \ | (rnd) << 24) #define __env_flags(env) ((env) & FE_ALL_EXCEPT) #define __env_mask(env) (((env) >> _FPUSW_SHIFT) \ & FE_ALL_EXCEPT) #define __env_round(env) (((env) >> 24) & _ROUND_MASK) #include "fenv-softfloat.h" #endif -#ifdef __GNUC_GNU_INLINE__ -#error "This file must be compiled with C99 'inline' semantics" -#endif - int (feclearexcept)(int excepts) { return (__feclearexcept_int(excepts)); } int (fegetexceptflag)(fexcept_t *flagp, int excepts) { return (__fegetexceptflag_int(flagp, excepts)); } int (fesetexceptflag)(const fexcept_t *flagp, int excepts) { return (__fesetexceptflag_int(flagp, excepts)); } int (feraiseexcept)(int excepts) { return (__feraiseexcept_int(excepts)); } int (fetestexcept)(int excepts) { return (__fetestexcept_int(excepts)); } int (fegetround)(void) { return (__fegetround_int()); } int (fesetround)(int round) { return (__fesetround_int(round)); } int (fegetenv)(fenv_t *envp) { return (__fegetenv_int(envp)); } int (feholdexcept)(fenv_t *envp) { return (__feholdexcept_int(envp)); } int (fesetenv)(const fenv_t *envp) { return (__fesetenv_int(envp)); } int (feupdateenv)(const fenv_t *envp) { return (__feupdateenv_int(envp)); } int (feenableexcept)(int mask) { return (__feenableexcept_int(mask)); } int (fedisableexcept)(int mask) { return (__fedisableexcept_int(mask)); } int (fegetexcept)(void) { return (__fegetexcept_int()); } #else /* !FENV_MANGLE && SOFTFP_ABI */ /* Set by libc when the VFP unit is enabled */ extern int _libc_arm_fpu_present; int __softfp_feclearexcept(int __excepts); int __softfp_fegetexceptflag(fexcept_t *__flagp, int __excepts); int __softfp_fesetexceptflag(const fexcept_t *__flagp, int __excepts); int __softfp_feraiseexcept(int __excepts); int __softfp_fetestexcept(int __excepts); int __softfp_fegetround(void); int __softfp_fesetround(int __round); int __softfp_fegetenv(fenv_t *__envp); int __softfp_feholdexcept(fenv_t *__envp); int __softfp_fesetenv(const fenv_t *__envp); int __softfp_feupdateenv(const fenv_t *__envp); int __softfp_feenableexcept(int __mask); int __softfp_fedisableexcept(int __mask); int __softfp_fegetexcept(void); int __vfp_feclearexcept(int __excepts); int __vfp_fegetexceptflag(fexcept_t *__flagp, int __excepts); int __vfp_fesetexceptflag(const fexcept_t *__flagp, int __excepts); int __vfp_feraiseexcept(int __excepts); int __vfp_fetestexcept(int __excepts); int __vfp_fegetround(void); int __vfp_fesetround(int __round); int __vfp_fegetenv(fenv_t *__envp); int __vfp_feholdexcept(fenv_t *__envp); int __vfp_fesetenv(const fenv_t *__envp); int __vfp_feupdateenv(const fenv_t *__envp); int __vfp_feenableexcept(int __mask); int __vfp_fedisableexcept(int __mask); int __vfp_fegetexcept(void); static int __softfp_round_to_vfp(int round) { switch (round) { case FE_TONEAREST: default: return VFP_FE_TONEAREST; case FE_TOWARDZERO: return VFP_FE_TOWARDZERO; case FE_UPWARD: return VFP_FE_UPWARD; case FE_DOWNWARD: return VFP_FE_DOWNWARD; } } static int __softfp_round_from_vfp(int round) { switch (round) { case VFP_FE_TONEAREST: default: return FE_TONEAREST; case VFP_FE_TOWARDZERO: return FE_TOWARDZERO; case VFP_FE_UPWARD: return FE_UPWARD; case VFP_FE_DOWNWARD: return FE_DOWNWARD; } } int (feclearexcept)(int __excepts) { if (_libc_arm_fpu_present) __vfp_feclearexcept(__excepts); __softfp_feclearexcept(__excepts); return (0); } int (fegetexceptflag)(fexcept_t *__flagp, int __excepts) { fexcept_t __vfp_flagp; __vfp_flagp = 0; if (_libc_arm_fpu_present) __vfp_fegetexceptflag(&__vfp_flagp, __excepts); __softfp_fegetexceptflag(__flagp, __excepts); *__flagp |= __vfp_flagp; return (0); } int (fesetexceptflag)(const fexcept_t *__flagp, int __excepts) { if (_libc_arm_fpu_present) __vfp_fesetexceptflag(__flagp, __excepts); __softfp_fesetexceptflag(__flagp, __excepts); return (0); } int (feraiseexcept)(int __excepts) { if (_libc_arm_fpu_present) __vfp_feraiseexcept(__excepts); __softfp_feraiseexcept(__excepts); return (0); } int (fetestexcept)(int __excepts) { int __got_excepts; __got_excepts = 0; if (_libc_arm_fpu_present) __got_excepts = __vfp_fetestexcept(__excepts); __got_excepts |= __softfp_fetestexcept(__excepts); return (__got_excepts); } int (fegetround)(void) { if (_libc_arm_fpu_present) return __softfp_round_from_vfp(__vfp_fegetround()); return __softfp_fegetround(); } int (fesetround)(int __round) { if (_libc_arm_fpu_present) __vfp_fesetround(__softfp_round_to_vfp(__round)); __softfp_fesetround(__round); return (0); } int (fegetenv)(fenv_t *__envp) { fenv_t __vfp_envp; __vfp_envp = 0; if (_libc_arm_fpu_present) __vfp_fegetenv(&__vfp_envp); __softfp_fegetenv(__envp); *__envp |= __vfp_envp; return (0); } int (feholdexcept)(fenv_t *__envp) { fenv_t __vfp_envp; __vfp_envp = 0; if (_libc_arm_fpu_present) __vfp_feholdexcept(&__vfp_envp); __softfp_feholdexcept(__envp); *__envp |= __vfp_envp; return (0); } int (fesetenv)(const fenv_t *__envp) { if (_libc_arm_fpu_present) __vfp_fesetenv(__envp); __softfp_fesetenv(__envp); return (0); } int (feupdateenv)(const fenv_t *__envp) { if (_libc_arm_fpu_present) __vfp_feupdateenv(__envp); __softfp_feupdateenv(__envp); return (0); } int (feenableexcept)(int __mask) { int __unmasked; __unmasked = 0; if (_libc_arm_fpu_present) __unmasked = __vfp_feenableexcept(__mask); __unmasked |= __softfp_feenableexcept(__mask); return (__unmasked); } int (fedisableexcept)(int __mask) { int __unmasked; __unmasked = 0; if (_libc_arm_fpu_present) __unmasked = __vfp_fedisableexcept(__mask); __unmasked |= __softfp_fedisableexcept(__mask); return (__unmasked); } int (fegetexcept)(void) { int __unmasked; __unmasked = 0; if (_libc_arm_fpu_present) __unmasked = __vfp_fegetexcept(); __unmasked |= __softfp_fegetexcept(); return (__unmasked); } #endif diff --git a/lib/msun/i387/fenv.c b/lib/msun/i387/fenv.c index d3cdc2e1cafb..bae8de2fb969 100644 --- a/lib/msun/i387/fenv.c +++ b/lib/msun/i387/fenv.c @@ -1,254 +1,249 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2004-2005 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include -#define __fenv_static #include "fenv.h" -#ifdef __GNUC_GNU_INLINE__ -#error "This file must be compiled with C99 'inline' semantics" -#endif - const fenv_t __fe_dfl_env = { __INITIAL_NPXCW__, 0x0000, 0x0000, 0x1f80, 0xffffffff, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff } }; enum __sse_support __has_sse = #ifdef __SSE__ __SSE_YES; #else __SSE_UNK; #endif #define getfl(x) __asm __volatile("pushfl\n\tpopl %0" : "=mr" (*(x))) #define setfl(x) __asm __volatile("pushl %0\n\tpopfl" : : "g" (x)) #define cpuid_dx(x) __asm __volatile("pushl %%ebx\n\tmovl $1, %%eax\n\t" \ "cpuid\n\tpopl %%ebx" \ : "=d" (*(x)) : : "eax", "ecx") /* * Test for SSE support on this processor. We need to do this because * we need to use ldmxcsr/stmxcsr to get correct results if any part * of the program was compiled to use SSE floating-point, but we can't * use SSE on older processors. */ int __test_sse(void) { int flag, nflag; int dx_features; /* Am I a 486? */ getfl(&flag); nflag = flag ^ 0x200000; setfl(nflag); getfl(&nflag); if (flag != nflag) { /* Not a 486, so CPUID should work. */ cpuid_dx(&dx_features); if (dx_features & 0x2000000) { __has_sse = __SSE_YES; return (1); } } __has_sse = __SSE_NO; return (0); } int (feclearexcept)(int excepts) { return (__feclearexcept_int(excepts)); } int (fegetexceptflag)(fexcept_t *flagp, int excepts) { return (__fegetexceptflag_int(flagp, excepts)); } int fesetexceptflag(const fexcept_t *flagp, int excepts) { fenv_t env; __uint32_t mxcsr; __fnstenv(&env); env.__status &= ~excepts; env.__status |= *flagp & excepts; __fldenv(&env); if (__HAS_SSE()) { __stmxcsr(&mxcsr); mxcsr &= ~excepts; mxcsr |= *flagp & excepts; __ldmxcsr(&mxcsr); } return (0); } int feraiseexcept(int excepts) { fexcept_t ex = excepts; fesetexceptflag(&ex, excepts); __fwait(); return (0); } int (fetestexcept)(int excepts) { return (__fetestexcept_int(excepts)); } int (fegetround)(void) { return (__fegetround_int()); } int (fesetround)(int round) { return (__fesetround_int(round)); } int fegetenv(fenv_t *envp) { __uint32_t mxcsr; __fnstenv(envp); /* * fnstenv masks all exceptions, so we need to restore * the old control word to avoid this side effect. */ __fldcw(&envp->__control); if (__HAS_SSE()) { __stmxcsr(&mxcsr); __set_mxcsr(*envp, mxcsr); } return (0); } int feholdexcept(fenv_t *envp) { __uint32_t mxcsr; __fnstenv(envp); __fnclex(); if (__HAS_SSE()) { __stmxcsr(&mxcsr); __set_mxcsr(*envp, mxcsr); mxcsr &= ~FE_ALL_EXCEPT; mxcsr |= FE_ALL_EXCEPT << _SSE_EMASK_SHIFT; __ldmxcsr(&mxcsr); } return (0); } int (fesetenv)(const fenv_t *envp) { return (__fesetenv_int(envp)); } int feupdateenv(const fenv_t *envp) { __uint32_t mxcsr; __uint16_t status; __fnstsw(&status); if (__HAS_SSE()) __stmxcsr(&mxcsr); else mxcsr = 0; fesetenv(envp); feraiseexcept((mxcsr | status) & FE_ALL_EXCEPT); return (0); } int __feenableexcept(int mask) { __uint32_t mxcsr, omask; __uint16_t control; mask &= FE_ALL_EXCEPT; __fnstcw(&control); if (__HAS_SSE()) __stmxcsr(&mxcsr); else mxcsr = 0; omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control &= ~mask; __fldcw(&control); if (__HAS_SSE()) { mxcsr &= ~(mask << _SSE_EMASK_SHIFT); __ldmxcsr(&mxcsr); } return (omask); } int __fedisableexcept(int mask) { __uint32_t mxcsr, omask; __uint16_t control; mask &= FE_ALL_EXCEPT; __fnstcw(&control); if (__HAS_SSE()) __stmxcsr(&mxcsr); else mxcsr = 0; omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control |= mask; __fldcw(&control); if (__HAS_SSE()) { mxcsr |= mask << _SSE_EMASK_SHIFT; __ldmxcsr(&mxcsr); } return (omask); } __weak_reference(__feenableexcept, feenableexcept); __weak_reference(__fedisableexcept, fedisableexcept); diff --git a/lib/msun/powerpc/fenv.c b/lib/msun/powerpc/fenv.c index d1926155d087..3104b59d4dfb 100644 --- a/lib/msun/powerpc/fenv.c +++ b/lib/msun/powerpc/fenv.c @@ -1,114 +1,109 @@ /*- * SPDX-License-Identifier: BSD-2-Clause * * Copyright (c) 2004 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ -#define __fenv_static #include "fenv.h" -#ifdef __GNUC_GNU_INLINE__ -#error "This file must be compiled with C99 'inline' semantics" -#endif - const fenv_t __fe_dfl_env = 0x00000000; int (feclearexcept)(int excepts) { return (__feclearexcept_int(excepts)); } int (fegetexceptflag)(fexcept_t *flagp, int excepts) { return (__fegetexceptflag_int(flagp, excepts)); } int (fesetexceptflag)(const fexcept_t *flagp, int excepts) { return (__fesetexceptflag_int(flagp, excepts)); } int (feraiseexcept)(int excepts) { return (__feraiseexcept_int(excepts)); } int (fetestexcept)(int excepts) { return (__fetestexcept_int(excepts)); } int (fegetround)(void) { return (__fegetround_int()); } int (fesetround)(int round) { return (__fesetround_int(round)); } int (fegetenv)(fenv_t *envp) { return (__fegetenv_int(envp)); } int (feholdexcept)(fenv_t *envp) { return (__feholdexcept_int(envp)); } int (fesetenv)(const fenv_t *envp) { return (__fesetenv_int(envp)); } int (feupdateenv)(const fenv_t *envp) { return (__feupdateenv_int(envp)); } int (feenableexcept)(int mask) { return (__feenableexcept_int(mask)); } int (fedisableexcept)(int mask) { return (__fedisableexcept_int(mask)); } diff --git a/lib/msun/riscv/fenv.c b/lib/msun/riscv/fenv.c index 1f1f8eddc2d6..7fdedca1f09c 100644 --- a/lib/msun/riscv/fenv.c +++ b/lib/msun/riscv/fenv.c @@ -1,116 +1,111 @@ /*- * Copyright (c) 2004 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ -#define __fenv_static #include "fenv.h" -#ifdef __GNUC_GNU_INLINE__ -#error "This file must be compiled with C99 'inline' semantics" -#endif - /* * Hopefully the system ID byte is immutable, so it's valid to use * this as a default environment. */ const fenv_t __fe_dfl_env = 0; int (feclearexcept)(int excepts) { return (__feclearexcept_int(excepts)); } int (fegetexceptflag)(fexcept_t *flagp, int excepts) { return (__fegetexceptflag_int(flagp, excepts)); } int (fesetexceptflag)(const fexcept_t *flagp, int excepts) { return (__fesetexceptflag_int(flagp, excepts)); } int (feraiseexcept)(int excepts) { return (__feraiseexcept_int(excepts)); } int (fetestexcept)(int excepts) { return (__fetestexcept_int(excepts)); } int (fegetround)(void) { return (__fegetround_int()); } int (fesetround)(int round) { return (__fesetround_int(round)); } int (fegetenv)(fenv_t *envp) { return (__fegetenv_int(envp)); } int (feholdexcept)(fenv_t *envp) { return (__feholdexcept_int(envp)); } int (fesetenv)(const fenv_t *envp) { return (__fesetenv_int(envp)); } int (feupdateenv)(const fenv_t *envp) { return (__feupdateenv_int(envp)); } int (feenableexcept)(int mask) { return (__feenableexcept_int(mask)); } int (fedisableexcept)(int mask) { return (__fedisableexcept_int(mask)); }