Index: lib/libc/amd64/gen/fpgetmask.c =================================================================== --- lib/libc/amd64/gen/fpgetmask.c +++ lib/libc/amd64/gen/fpgetmask.c @@ -4,5 +4,5 @@ fp_except_t fpgetmask(void) { - return __fpgetmask(); + return __ieeefp_fpgetmask(); } Index: lib/libc/amd64/gen/fpgetprec.c =================================================================== --- lib/libc/amd64/gen/fpgetprec.c +++ lib/libc/amd64/gen/fpgetprec.c @@ -4,5 +4,5 @@ fp_prec_t fpgetprec(void) { - return __fpgetprec(); + return __ieeefp_fpgetprec(); } Index: lib/libc/amd64/gen/fpgetround.c =================================================================== --- lib/libc/amd64/gen/fpgetround.c +++ lib/libc/amd64/gen/fpgetround.c @@ -4,5 +4,5 @@ fp_rnd_t fpgetround(void) { - return __fpgetround(); + return __ieeefp_fpgetround(); } Index: lib/libc/amd64/gen/fpgetsticky.c =================================================================== --- lib/libc/amd64/gen/fpgetsticky.c +++ lib/libc/amd64/gen/fpgetsticky.c @@ -4,5 +4,5 @@ fp_except_t fpgetsticky(void) { - return __fpgetsticky(); + return __ieeefp_fpgetsticky(); } Index: lib/libc/amd64/gen/fpsetmask.c =================================================================== --- lib/libc/amd64/gen/fpsetmask.c +++ lib/libc/amd64/gen/fpsetmask.c @@ -4,5 +4,5 @@ fp_except_t fpsetmask(fp_except_t m) { - return (__fpsetmask(m)); + return (__ieeefp_fpsetmask(m)); } Index: lib/libc/amd64/gen/fpsetprec.c =================================================================== --- lib/libc/amd64/gen/fpsetprec.c +++ lib/libc/amd64/gen/fpsetprec.c @@ -4,5 +4,5 @@ fp_prec_t fpsetprec(fp_prec_t m) { - return (__fpsetprec(m)); + return (__ieeefp_fpsetprec(m)); } Index: lib/libc/amd64/gen/fpsetround.c =================================================================== --- lib/libc/amd64/gen/fpsetround.c +++ lib/libc/amd64/gen/fpsetround.c @@ -4,5 +4,5 @@ fp_rnd_t fpsetround(fp_rnd_t m) { - return (__fpsetround(m)); + return (__ieeefp_fpsetround(m)); } Index: lib/msun/amd64/fenv.c =================================================================== --- lib/msun/amd64/fenv.c +++ lib/msun/amd64/fenv.c @@ -57,15 +57,15 @@ { fenv_t env; - __fnstenv(&env.__x87); + __fenv_fnstenv(&env.__x87); env.__x87.__status &= ~excepts; env.__x87.__status |= *flagp & excepts; - __fldenv(env.__x87); + __fenv_fldenv(env.__x87); - __stmxcsr(&env.__mxcsr); + __fenv_stmxcsr(&env.__mxcsr); env.__mxcsr &= ~excepts; env.__mxcsr |= *flagp & excepts; - __ldmxcsr(env.__mxcsr); + __fenv_ldmxcsr(env.__mxcsr); return (0); } @@ -76,7 +76,7 @@ fexcept_t ex = excepts; fesetexceptflag(&ex, excepts); - __fwait(); + __fenv_fwait(); return (0); } @@ -88,13 +88,13 @@ fegetenv(fenv_t *envp) { - __fnstenv(&envp->__x87); - __stmxcsr(&envp->__mxcsr); + __fenv_fnstenv(&envp->__x87); + __fenv_stmxcsr(&envp->__mxcsr); /* * fnstenv masks all exceptions, so we need to restore the * control word to avoid this side effect. */ - __fldcw(envp->__x87.__control); + __fenv_fldcw(envp->__x87.__control); return (0); } @@ -103,13 +103,13 @@ { __uint32_t mxcsr; - __stmxcsr(&mxcsr); - __fnstenv(&envp->__x87); - __fnclex(); + __fenv_stmxcsr(&mxcsr); + __fenv_fnstenv(&envp->__x87); + __fenv_fnclex(); envp->__mxcsr = mxcsr; mxcsr &= ~FE_ALL_EXCEPT; mxcsr |= FE_ALL_EXCEPT << _SSE_EMASK_SHIFT; - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); return (0); } @@ -121,8 +121,8 @@ __uint32_t mxcsr; __uint16_t status; - __fnstsw(&status); - __stmxcsr(&mxcsr); + __fenv_fnstsw(&status); + __fenv_stmxcsr(&mxcsr); fesetenv(envp); feraiseexcept((mxcsr | status) & FE_ALL_EXCEPT); return (0); @@ -135,13 +135,13 @@ __uint16_t control; mask &= FE_ALL_EXCEPT; - __fnstcw(&control); - __stmxcsr(&mxcsr); + __fenv_fnstcw(&control); + __fenv_stmxcsr(&mxcsr); omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control &= ~mask; - __fldcw(control); + __fenv_fldcw(control); mxcsr &= ~(mask << _SSE_EMASK_SHIFT); - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); return (omask); } @@ -152,13 +152,13 @@ __uint16_t control; mask &= FE_ALL_EXCEPT; - __fnstcw(&control); - __stmxcsr(&mxcsr); + __fenv_fnstcw(&control); + __fenv_stmxcsr(&mxcsr); omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control |= mask; - __fldcw(control); + __fenv_fldcw(control); mxcsr |= mask << _SSE_EMASK_SHIFT; - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); return (omask); } Index: lib/msun/i387/fenv.c =================================================================== --- lib/msun/i387/fenv.c +++ lib/msun/i387/fenv.c @@ -100,16 +100,16 @@ fenv_t env; __uint32_t mxcsr; - __fnstenv(&env); + __fenv_fnstenv(&env); env.__status &= ~excepts; env.__status |= *flagp & excepts; - __fldenv(env); + __fenv_fldenv(env); if (__HAS_SSE()) { - __stmxcsr(&mxcsr); + __fenv_stmxcsr(&mxcsr); mxcsr &= ~excepts; mxcsr |= *flagp & excepts; - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); } return (0); @@ -121,7 +121,7 @@ fexcept_t ex = excepts; fesetexceptflag(&ex, excepts); - __fwait(); + __fenv_fwait(); return (0); } @@ -134,15 +134,15 @@ { __uint32_t mxcsr; - __fnstenv(envp); + __fenv_fnstenv(envp); /* * fnstenv masks all exceptions, so we need to restore * the old control word to avoid this side effect. */ - __fldcw(envp->__control); + __fenv_fldcw(envp->__control); if (__HAS_SSE()) { - __stmxcsr(&mxcsr); - __set_mxcsr(*envp, mxcsr); + __fenv_stmxcsr(&mxcsr); + __fenv_set_mxcsr(*envp, mxcsr); } return (0); } @@ -152,14 +152,14 @@ { __uint32_t mxcsr; - __fnstenv(envp); - __fnclex(); + __fenv_fnstenv(envp); + __fenv_fnclex(); if (__HAS_SSE()) { - __stmxcsr(&mxcsr); - __set_mxcsr(*envp, mxcsr); + __fenv_stmxcsr(&mxcsr); + __fenv_set_mxcsr(*envp, mxcsr); mxcsr &= ~FE_ALL_EXCEPT; mxcsr |= FE_ALL_EXCEPT << _SSE_EMASK_SHIFT; - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); } return (0); } @@ -172,9 +172,9 @@ __uint32_t mxcsr; __uint16_t status; - __fnstsw(&status); + __fenv_fnstsw(&status); if (__HAS_SSE()) - __stmxcsr(&mxcsr); + __fenv_stmxcsr(&mxcsr); else mxcsr = 0; fesetenv(envp); @@ -189,17 +189,17 @@ __uint16_t control; mask &= FE_ALL_EXCEPT; - __fnstcw(&control); + __fenv_fnstcw(&control); if (__HAS_SSE()) - __stmxcsr(&mxcsr); + __fenv_stmxcsr(&mxcsr); else mxcsr = 0; omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control &= ~mask; - __fldcw(control); + __fenv_fldcw(control); if (__HAS_SSE()) { mxcsr &= ~(mask << _SSE_EMASK_SHIFT); - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); } return (omask); } @@ -211,17 +211,17 @@ __uint16_t control; mask &= FE_ALL_EXCEPT; - __fnstcw(&control); + __fenv_fnstcw(&control); if (__HAS_SSE()) - __stmxcsr(&mxcsr); + __fenv_stmxcsr(&mxcsr); else mxcsr = 0; omask = ~(control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; control |= mask; - __fldcw(control); + __fenv_fldcw(control); if (__HAS_SSE()) { mxcsr |= mask << _SSE_EMASK_SHIFT; - __ldmxcsr(mxcsr); + __fenv_ldmxcsr(mxcsr); } return (omask); } Index: lib/msun/tests/Makefile =================================================================== --- lib/msun/tests/Makefile +++ lib/msun/tests/Makefile @@ -84,10 +84,6 @@ LIBADD+= m -.if ${MACHINE_CPUARCH} == "i386" -# XXX: __fldcw macro mismatch between fenv.h and ieeefp.h . -CWARNFLAGS.clang+= -Wno-error=macro-redefined -.endif WARNS?= 1 # Copied from lib/msun/Makefile Index: lib/msun/x86/fenv.h =================================================================== --- lib/msun/x86/fenv.h +++ lib/msun/x86/fenv.h @@ -97,18 +97,18 @@ extern const fenv_t __fe_dfl_env; #define FE_DFL_ENV (&__fe_dfl_env) -#define __fldcw(__cw) __asm __volatile("fldcw %0" : : "m" (__cw)) -#define __fldenv(__env) __asm __volatile("fldenv %0" : : "m" (__env)) -#define __fldenvx(__env) __asm __volatile("fldenv %0" : : "m" (__env) \ +#define __fenv_fldcw(__cw) __asm __volatile("fldcw %0" : : "m" (__cw)) +#define __fenv_fldenv(__env) __asm __volatile("fldenv %0" : : "m" (__env)) +#define __fenv_fldenvx(__env) __asm __volatile("fldenv %0" : : "m" (__env) \ : "st", "st(1)", "st(2)", "st(3)", "st(4)", \ "st(5)", "st(6)", "st(7)") -#define __fnclex() __asm __volatile("fnclex") -#define __fnstenv(__env) __asm __volatile("fnstenv %0" : "=m" (*(__env))) -#define __fnstcw(__cw) __asm __volatile("fnstcw %0" : "=m" (*(__cw))) -#define __fnstsw(__sw) __asm __volatile("fnstsw %0" : "=am" (*(__sw))) -#define __fwait() __asm __volatile("fwait") -#define __ldmxcsr(__csr) __asm __volatile("ldmxcsr %0" : : "m" (__csr)) -#define __stmxcsr(__csr) __asm __volatile("stmxcsr %0" : "=m" (*(__csr))) +#define __fenv_fnclex() __asm __volatile("fnclex") +#define __fenv_fnstenv(__env) __asm __volatile("fnstenv %0" : "=m" (*(__env))) +#define __fenv_fnstcw(__cw) __asm __volatile("fnstcw %0" : "=m" (*(__cw))) +#define __fenv_fnstsw(__sw) __asm __volatile("fnstsw %0" : "=am" (*(__sw))) +#define __fenv_fwait() __asm __volatile("fwait") +#define __fenv_ldmxcsr(__csr) __asm __volatile("ldmxcsr %0" : : "m" (__csr)) +#define __fenv_stmxcsr(__csr) __asm __volatile("stmxcsr %0" : "=m" (*(__csr))) int fegetenv(fenv_t *__envp); int feholdexcept(fenv_t *__envp); @@ -127,7 +127,7 @@ * out to be about 5 times faster than reading it on the SSE * unit on an Opteron 244. */ - __fnstcw(&__control); + __fenv_fnstcw(&__control); return (__control & _ROUND_MASK); } @@ -146,7 +146,7 @@ * We assume that the masks for the x87 and the SSE unit are * the same. */ - __fnstcw(&__control); + __fenv_fnstcw(&__control); return (~__control & FE_ALL_EXCEPT); } @@ -165,9 +165,9 @@ (__has_sse == __SSE_UNK && __test_sse())) #endif -#define __get_mxcsr(env) (((env).__mxcsr_hi << 16) | \ +#define __fenv_get_mxcsr(env) (((env).__mxcsr_hi << 16) | \ ((env).__mxcsr_lo)) -#define __set_mxcsr(env, x) do { \ +#define __fenv_set_mxcsr(env, x) do { \ (env).__mxcsr_hi = (__uint32_t)(x) >> 16; \ (env).__mxcsr_lo = (__uint16_t)(x); \ } while (0) @@ -179,16 +179,16 @@ __uint32_t __mxcsr; if (__excepts == FE_ALL_EXCEPT) { - __fnclex(); + __fenv_fnclex(); } else { - __fnstenv(&__env); + __fenv_fnstenv(&__env); __env.__status &= ~__excepts; - __fldenv(__env); + __fenv_fldenv(__env); } if (__HAS_SSE()) { - __stmxcsr(&__mxcsr); + __fenv_stmxcsr(&__mxcsr); __mxcsr &= ~__excepts; - __ldmxcsr(__mxcsr); + __fenv_ldmxcsr(__mxcsr); } return (0); } @@ -199,9 +199,9 @@ __uint32_t __mxcsr; __uint16_t __status; - __fnstsw(&__status); + __fenv_fnstsw(&__status); if (__HAS_SSE()) - __stmxcsr(&__mxcsr); + __fenv_stmxcsr(&__mxcsr); else __mxcsr = 0; *__flagp = (__mxcsr | __status) & __excepts; @@ -214,9 +214,9 @@ __uint32_t __mxcsr; __uint16_t __status; - __fnstsw(&__status); + __fenv_fnstsw(&__status); if (__HAS_SSE()) - __stmxcsr(&__mxcsr); + __fenv_stmxcsr(&__mxcsr); else __mxcsr = 0; return ((__status | __mxcsr) & __excepts); @@ -231,16 +231,16 @@ if (__round & ~_ROUND_MASK) return (-1); - __fnstcw(&__control); + __fenv_fnstcw(&__control); __control &= ~_ROUND_MASK; __control |= __round; - __fldcw(__control); + __fenv_fldcw(__control); if (__HAS_SSE()) { - __stmxcsr(&__mxcsr); + __fenv_stmxcsr(&__mxcsr); __mxcsr &= ~(_ROUND_MASK << _SSE_ROUND_SHIFT); __mxcsr |= __round << _SSE_ROUND_SHIFT; - __ldmxcsr(__mxcsr); + __fenv_ldmxcsr(__mxcsr); } return (0); @@ -252,8 +252,8 @@ fenv_t __env = *__envp; __uint32_t __mxcsr; - __mxcsr = __get_mxcsr(__env); - __set_mxcsr(__env, 0xffffffff); + __mxcsr = __fenv_get_mxcsr(__env); + __fenv_set_mxcsr(__env, 0xffffffff); /* * XXX Using fldenvx() instead of fldenv() tells the compiler that this * instruction clobbers the i387 register stack. This happens because @@ -262,9 +262,9 @@ * function calls to clobber the i387 regs. However, fesetenv() is * inlined, so we need to be more careful. */ - __fldenvx(__env); + __fenv_fldenvx(__env); if (__HAS_SSE()) - __ldmxcsr(__mxcsr); + __fenv_ldmxcsr(__mxcsr); return (0); } @@ -276,15 +276,15 @@ fenv_t __env; if (__excepts == FE_ALL_EXCEPT) { - __fnclex(); + __fenv_fnclex(); } else { - __fnstenv(&__env.__x87); + __fenv_fnstenv(&__env.__x87); __env.__x87.__status &= ~__excepts; - __fldenv(__env.__x87); + __fenv_fldenv(__env.__x87); } - __stmxcsr(&__env.__mxcsr); + __fenv_stmxcsr(&__env.__mxcsr); __env.__mxcsr &= ~__excepts; - __ldmxcsr(__env.__mxcsr); + __fenv_ldmxcsr(__env.__mxcsr); return (0); } @@ -294,8 +294,8 @@ __uint32_t __mxcsr; __uint16_t __status; - __stmxcsr(&__mxcsr); - __fnstsw(&__status); + __fenv_stmxcsr(&__mxcsr); + __fenv_fnstsw(&__status); *__flagp = (__mxcsr | __status) & __excepts; return (0); } @@ -306,8 +306,8 @@ __uint32_t __mxcsr; __uint16_t __status; - __stmxcsr(&__mxcsr); - __fnstsw(&__status); + __fenv_stmxcsr(&__mxcsr); + __fenv_fnstsw(&__status); return ((__status | __mxcsr) & __excepts); } @@ -320,15 +320,15 @@ if (__round & ~_ROUND_MASK) return (-1); - __fnstcw(&__control); + __fenv_fnstcw(&__control); __control &= ~_ROUND_MASK; __control |= __round; - __fldcw(__control); + __fenv_fldcw(__control); - __stmxcsr(&__mxcsr); + __fenv_stmxcsr(&__mxcsr); __mxcsr &= ~(_ROUND_MASK << _SSE_ROUND_SHIFT); __mxcsr |= __round << _SSE_ROUND_SHIFT; - __ldmxcsr(__mxcsr); + __fenv_ldmxcsr(__mxcsr); return (0); } @@ -345,8 +345,8 @@ * function calls to clobber the i387 regs. However, fesetenv() is * inlined, so we need to be more careful. */ - __fldenvx(__envp->__x87); - __ldmxcsr(__envp->__mxcsr); + __fenv_fldenvx(__envp->__x87); + __fenv_ldmxcsr(__envp->__mxcsr); return (0); } Index: sys/amd64/include/ieeefp.h =================================================================== --- sys/amd64/include/ieeefp.h +++ sys/amd64/include/ieeefp.h @@ -128,13 +128,13 @@ #ifdef __GNUCLIKE_ASM -#define __fldcw(addr) __asm __volatile("fldcw %0" : : "m" (*(addr))) -#define __fldenv(addr) __asm __volatile("fldenv %0" : : "m" (*(addr))) -#define __fnstcw(addr) __asm __volatile("fnstcw %0" : "=m" (*(addr))) -#define __fnstenv(addr) __asm __volatile("fnstenv %0" : "=m" (*(addr))) -#define __fnstsw(addr) __asm __volatile("fnstsw %0" : "=m" (*(addr))) -#define __ldmxcsr(addr) __asm __volatile("ldmxcsr %0" : : "m" (*(addr))) -#define __stmxcsr(addr) __asm __volatile("stmxcsr %0" : "=m" (*(addr))) +#define __ieeefp_fldcw(addr) __asm __volatile("fldcw %0" : : "m" (*(addr))) +#define __ieeefp_fldenv(addr) __asm __volatile("fldenv %0" : : "m" (*(addr))) +#define __ieeefp_fnstcw(addr) __asm __volatile("fnstcw %0" : "=m" (*(addr))) +#define __ieeefp_fnstenv(addr) __asm __volatile("fnstenv %0" : "=m" (*(addr))) +#define __ieeefp_fnstsw(addr) __asm __volatile("fnstsw %0" : "=m" (*(addr))) +#define __ieeefp_ldmxcsr(addr) __asm __volatile("ldmxcsr %0" : : "m" (*(addr))) +#define __ieeefp_stmxcsr(addr) __asm __volatile("stmxcsr %0" : "=m" (*(addr))) /* * Load the control word. Be careful not to trap if there is a currently @@ -144,7 +144,7 @@ * is very inefficient, so only do it when necessary. */ static __inline void -__fnldcw(unsigned short _cw, unsigned short _newcw) +__ieeefp_fnldcw(unsigned short _cw, unsigned short _newcw) { struct { unsigned _cw; @@ -153,15 +153,15 @@ unsigned short _sw; if ((_cw & FP_MSKS_FLD) != FP_MSKS_FLD) { - __fnstsw(&_sw); + __ieeefp_fnstsw(&_sw); if (((_sw & ~_cw) & FP_STKY_FLD) != 0) { - __fnstenv(&_env); + __ieeefp_fnstenv(&_env); _env._cw = _newcw; - __fldenv(&_env); + __ieeefp_fldenv(&_env); return; } } - __fldcw(&_newcw); + __ieeefp_fldcw(&_newcw); } /* @@ -176,30 +176,30 @@ */ static __inline fp_rnd_t -__fpgetround(void) +__ieeefp_fpgetround(void) { unsigned short _cw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); return ((fp_rnd_t)((_cw & FP_RND_FLD) >> FP_RND_OFF)); } static __inline fp_rnd_t -__fpsetround(fp_rnd_t _m) +__ieeefp_fpsetround(fp_rnd_t _m) { fp_rnd_t _p; unsigned _mxcsr; unsigned short _cw, _newcw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); _p = (fp_rnd_t)((_cw & FP_RND_FLD) >> FP_RND_OFF); _newcw = _cw & ~FP_RND_FLD; _newcw |= (_m << FP_RND_OFF) & FP_RND_FLD; - __fnldcw(_cw, _newcw); - __stmxcsr(&_mxcsr); + __ieeefp_fnldcw(_cw, _newcw); + __ieeefp_stmxcsr(&_mxcsr); _mxcsr &= ~SSE_RND_FLD; _mxcsr |= (_m << SSE_RND_OFF) & SSE_RND_FLD; - __ldmxcsr(&_mxcsr); + __ieeefp_ldmxcsr(&_mxcsr); return (_p); } @@ -209,25 +209,25 @@ */ static __inline fp_prec_t -__fpgetprec(void) +__ieeefp_fpgetprec(void) { unsigned short _cw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); return ((fp_prec_t)((_cw & FP_PRC_FLD) >> FP_PRC_OFF)); } static __inline fp_prec_t -__fpsetprec(fp_prec_t _m) +__ieeefp_fpsetprec(fp_prec_t _m) { fp_prec_t _p; unsigned short _cw, _newcw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); _p = (fp_prec_t)((_cw & FP_PRC_FLD) >> FP_PRC_OFF); _newcw = _cw & ~FP_PRC_FLD; _newcw |= (_m << FP_PRC_OFF) & FP_PRC_FLD; - __fnldcw(_cw, _newcw); + __ieeefp_fnldcw(_cw, _newcw); return (_p); } @@ -238,43 +238,43 @@ */ static __inline fp_except_t -__fpgetmask(void) +__ieeefp_fpgetmask(void) { unsigned short _cw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); return ((~_cw & FP_MSKS_FLD) >> FP_MSKS_OFF); } static __inline fp_except_t -__fpsetmask(fp_except_t _m) +__ieeefp_fpsetmask(fp_except_t _m) { fp_except_t _p; unsigned _mxcsr; unsigned short _cw, _newcw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); _p = (~_cw & FP_MSKS_FLD) >> FP_MSKS_OFF; _newcw = _cw & ~FP_MSKS_FLD; _newcw |= (~_m << FP_MSKS_OFF) & FP_MSKS_FLD; - __fnldcw(_cw, _newcw); - __stmxcsr(&_mxcsr); + __ieeefp_fnldcw(_cw, _newcw); + __ieeefp_stmxcsr(&_mxcsr); /* XXX should we clear non-ieee SSE_DAZ_FLD and SSE_FZ_FLD ? */ _mxcsr &= ~SSE_MSKS_FLD; _mxcsr |= (~_m << SSE_MSKS_OFF) & SSE_MSKS_FLD; - __ldmxcsr(&_mxcsr); + __ieeefp_ldmxcsr(&_mxcsr); return (_p); } static __inline fp_except_t -__fpgetsticky(void) +__ieeefp_fpgetsticky(void) { unsigned _ex, _mxcsr; unsigned short _sw; - __fnstsw(&_sw); + __ieeefp_fnstsw(&_sw); _ex = (_sw & FP_STKY_FLD) >> FP_STKY_OFF; - __stmxcsr(&_mxcsr); + __ieeefp_stmxcsr(&_mxcsr); _ex |= (_mxcsr & SSE_STKY_FLD) >> SSE_STKY_OFF; return ((fp_except_t)_ex); } @@ -283,13 +283,13 @@ #if !defined(__IEEEFP_NOINLINES__) && defined(__GNUCLIKE_ASM) -#define fpgetmask() __fpgetmask() -#define fpgetprec() __fpgetprec() -#define fpgetround() __fpgetround() -#define fpgetsticky() __fpgetsticky() -#define fpsetmask(m) __fpsetmask(m) -#define fpsetprec(m) __fpsetprec(m) -#define fpsetround(m) __fpsetround(m) +#define fpgetmask() __ieeefp_fpgetmask() +#define fpgetprec() __ieeefp_fpgetprec() +#define fpgetround() __ieeefp_fpgetround() +#define fpgetsticky() __ieeefp_fpgetsticky() +#define fpsetmask(m) __ieeefp_fpsetmask(m) +#define fpsetprec(m) __ieeefp_fpsetprec(m) +#define fpsetround(m) __ieeefp_fpsetround(m) #else /* !(!__IEEEFP_NOINLINES__ && __GNUCLIKE_ASM) */ Index: sys/i386/include/ieeefp.h =================================================================== --- sys/i386/include/ieeefp.h +++ sys/i386/include/ieeefp.h @@ -110,12 +110,12 @@ #ifdef __GNUCLIKE_ASM -#define __fldcw(addr) __asm __volatile("fldcw %0" : : "m" (*(addr))) -#define __fldenv(addr) __asm __volatile("fldenv %0" : : "m" (*(addr))) -#define __fnclex() __asm __volatile("fnclex") -#define __fnstcw(addr) __asm __volatile("fnstcw %0" : "=m" (*(addr))) -#define __fnstenv(addr) __asm __volatile("fnstenv %0" : "=m" (*(addr))) -#define __fnstsw(addr) __asm __volatile("fnstsw %0" : "=m" (*(addr))) +#define __ieeefp_fldcw(addr) __asm __volatile("fldcw %0" : : "m" (*(addr))) +#define __ieeefp_fldenv(addr) __asm __volatile("fldenv %0" : : "m" (*(addr))) +#define __ieeefp_fnclex() __asm __volatile("fnclex") +#define __ieeefp_fnstcw(addr) __asm __volatile("fnstcw %0" : "=m" (*(addr))) +#define __ieeefp_fnstenv(addr) __asm __volatile("fnstenv %0" : "=m" (*(addr))) +#define __ieeefp_fnstsw(addr) __asm __volatile("fnstsw %0" : "=m" (*(addr))) /* * Load the control word. Be careful not to trap if there is a currently @@ -125,7 +125,7 @@ * is very inefficient, so only do it when necessary. */ static __inline void -__fnldcw(unsigned short _cw, unsigned short _newcw) +__ieeefp_fnldcw(unsigned short _cw, unsigned short _newcw) { struct { unsigned _cw; @@ -134,15 +134,15 @@ unsigned short _sw; if ((_cw & FP_MSKS_FLD) != FP_MSKS_FLD) { - __fnstsw(&_sw); + __ieeefp_fnstsw(&_sw); if (((_sw & ~_cw) & FP_STKY_FLD) != 0) { - __fnstenv(&_env); + __ieeefp_fnstenv(&_env); _env._cw = _newcw; - __fldenv(&_env); + __ieeefp_fldenv(&_env); return; } } - __fldcw(&_newcw); + __ieeefp_fldcw(&_newcw); } static __inline fp_rnd_t @@ -150,7 +150,7 @@ { unsigned short _cw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); return ((fp_rnd_t)((_cw & FP_RND_FLD) >> FP_RND_OFF)); } @@ -160,11 +160,11 @@ fp_rnd_t _p; unsigned short _cw, _newcw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); _p = (fp_rnd_t)((_cw & FP_RND_FLD) >> FP_RND_OFF); _newcw = _cw & ~FP_RND_FLD; _newcw |= (_m << FP_RND_OFF) & FP_RND_FLD; - __fnldcw(_cw, _newcw); + __ieeefp_fnldcw(_cw, _newcw); return (_p); } @@ -173,7 +173,7 @@ { unsigned short _cw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); return ((fp_prec_t)((_cw & FP_PRC_FLD) >> FP_PRC_OFF)); } @@ -183,11 +183,11 @@ fp_prec_t _p; unsigned short _cw, _newcw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); _p = (fp_prec_t)((_cw & FP_PRC_FLD) >> FP_PRC_OFF); _newcw = _cw & ~FP_PRC_FLD; _newcw |= (_m << FP_PRC_OFF) & FP_PRC_FLD; - __fnldcw(_cw, _newcw); + __ieeefp_fnldcw(_cw, _newcw); return (_p); } @@ -202,7 +202,7 @@ { unsigned short _cw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); return ((~_cw & FP_MSKS_FLD) >> FP_MSKS_OFF); } @@ -212,11 +212,11 @@ fp_except_t _p; unsigned short _cw, _newcw; - __fnstcw(&_cw); + __ieeefp_fnstcw(&_cw); _p = (~_cw & FP_MSKS_FLD) >> FP_MSKS_OFF; _newcw = _cw & ~FP_MSKS_FLD; _newcw |= (~_m << FP_MSKS_OFF) & FP_MSKS_FLD; - __fnldcw(_cw, _newcw); + __ieeefp_fnldcw(_cw, _newcw); return (_p); } @@ -226,7 +226,7 @@ unsigned _ex; unsigned short _sw; - __fnstsw(&_sw); + __ieeefp_fnstsw(&_sw); _ex = (_sw & FP_STKY_FLD) >> FP_STKY_OFF; return ((fp_except_t)_ex); } @@ -246,12 +246,12 @@ if ((_p & ~_m) == _p) return (_p); if ((_p & ~_m) == 0) { - __fnclex(); + __ieeefp_fnclex(); return (_p); } - __fnstenv(&_env); + __ieeefp_fnstenv(&_env); _env._sw &= ~_m; - __fldenv(&_env); + __ieeefp_fldenv(&_env); return (_p); }