1 /* $NetBSD: fenv.c,v 1.6 2013/11/11 00:31:51 joerg Exp $ */ 2 3 /*- 4 * Copyright (c) 2004-2005 David Schultz <das (at) FreeBSD.ORG> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __RCSID("$NetBSD: fenv.c,v 1.6 2013/11/11 00:31:51 joerg Exp $"); 31 32 #include <assert.h> 33 #include <fenv.h> 34 #include <stddef.h> 35 #include <string.h> 36 37 /* Load x87 Control Word */ 38 #define __fldcw(__cw) __asm__ __volatile__ \ 39 ("fldcw %0" : : "m" (__cw)) 40 41 /* No-Wait Store Control Word */ 42 #define __fnstcw(__cw) __asm__ __volatile__ \ 43 ("fnstcw %0" : "=m" (*(__cw))) 44 45 /* No-Wait Store Status Word */ 46 #define __fnstsw(__sw) __asm__ __volatile__ \ 47 ("fnstsw %0" : "=am" (*(__sw))) 48 49 /* No-Wait Clear Exception Flags */ 50 #define __fnclex() __asm__ __volatile__ \ 51 ("fnclex") 52 53 /* Load x87 Environment */ 54 #define __fldenv(__env) __asm__ __volatile__ \ 55 ("fldenv %0" : : "m" (__env)) 56 57 /* No-Wait Store x87 environment */ 58 #define __fnstenv(__env) __asm__ __volatile__ \ 59 ("fnstenv %0" : "=m" (*(__env))) 60 61 /* Check for and handle pending unmasked x87 pending FPU exceptions */ 62 #define __fwait(__env) __asm__ __volatile__ \ 63 ("fwait") 64 65 /* Load the MXCSR register */ 66 #define __ldmxcsr(__mxcsr) __asm__ __volatile__ \ 67 ("ldmxcsr %0" : : "m" (__mxcsr)) 68 69 /* Store the MXCSR register state */ 70 #define __stmxcsr(__mxcsr) __asm__ __volatile__ \ 71 ("stmxcsr %0" : "=m" (*(__mxcsr))) 72 73 /* 74 * The following constant represents the default floating-point environment 75 * (that is, the one installed at program startup) and has type pointer to 76 * const-qualified fenv_t. 77 * 78 * It can be used as an argument to the functions within the <fenv.h> header 79 * that manage the floating-point environment, namely fesetenv() and 80 * feupdateenv(). 81 * 82 * x87 fpu registers are 16bit wide. The upper bits, 31-16, are marked as 83 * RESERVED. We provide a partial floating-point environment, where we 84 * define only the lower bits. The reserved bits are extracted and set by 85 * the consumers of FE_DFL_ENV, during runtime. 86 */ 87 fenv_t __fe_dfl_env = { 88 { 89 __NetBSD_NPXCW__, /* Control word register */ 90 0x00000000, /* Status word register */ 91 0x0000ffff, /* Tag word register */ 92 { 93 0x00000000, 94 0x00000000, 95 0x00000000, 96 0x00000000, 97 }, 98 }, 99 __INITIAL_MXCSR__ /* MXCSR register */ 100 }; 101 #define FE_DFL_ENV ((const fenv_t *) &__fe_dfl_env) 102 103 static void __init_libm(void) __attribute__ ((constructor, used)); 104 105 static void __init_libm(void) 106 { 107 uint16_t control; 108 109 __fnstcw(&control); 110 __fe_dfl_env.x87.control = control; 111 } 112 113 114 /* 115 * The feclearexcept() function clears the supported floating-point exceptions 116 * represented by `excepts'. 117 */ 118 int 119 feclearexcept(int excepts) 120 { 121 fenv_t fenv; 122 int ex; 123 124 _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0); 125 126 ex = excepts & FE_ALL_EXCEPT; 127 128 /* Store the current x87 floating-point environment */ 129 __fnstenv(&fenv); 130 131 /* Clear the requested floating-point exceptions */ 132 fenv.x87.status &= ~ex; 133 134 /* Load the x87 floating-point environent */ 135 __fldenv(fenv); 136 137 /* Same for SSE environment */ 138 __stmxcsr(&fenv.mxcsr); 139 fenv.mxcsr &= ~ex; 140 __ldmxcsr(fenv.mxcsr); 141 142 /* Success */ 143 return (0); 144 } 145 146 /* 147 * The fegetexceptflag() function stores an implementation-defined 148 * representation of the states of the floating-point status flags indicated by 149 * the argument excepts in the object pointed to by the argument flagp. 150 */ 151 int 152 fegetexceptflag(fexcept_t *flagp, int excepts) 153 { 154 uint32_t mxcsr; 155 uint16_t x87_status; 156 int ex; 157 158 _DIAGASSERT(flagp != NULL); 159 _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0); 160 161 ex = excepts & FE_ALL_EXCEPT; 162 163 /* Store the current x87 status register */ 164 __fnstsw(&x87_status); 165 166 /* Store the MXCSR register */ 167 __stmxcsr(&mxcsr); 168 169 /* Store the results in flagp */ 170 *flagp = (x87_status | mxcsr) & ex; 171 172 /* Success */ 173 return (0); 174 } 175 176 /* 177 * The feraiseexcept() function raises the supported floating-point exceptions 178 * represented by the argument `excepts'. 179 * 180 * The standard explicitly allows us to execute an instruction that has the 181 * exception as a side effect, but we choose to manipulate the status register 182 * directly. 183 * 184 * The validation of input is being deferred to fesetexceptflag(). 185 */ 186 int 187 feraiseexcept(int excepts) 188 { 189 int ex; 190 191 _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0); 192 193 ex = excepts & FE_ALL_EXCEPT; 194 fesetexceptflag((unsigned int *)&ex, ex); 195 __fwait(); 196 197 /* Success */ 198 return (0); 199 } 200 201 /* 202 * This function sets the floating-point status flags indicated by the argument 203 * `excepts' to the states stored in the object pointed to by `flagp'. It does 204 * NOT raise any floating-point exceptions, but only sets the state of the flags. 205 */ 206 int 207 fesetexceptflag(const fexcept_t *flagp, int excepts) 208 { 209 fenv_t fenv; 210 int ex; 211 212 _DIAGASSERT(flagp != NULL); 213 _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0); 214 215 ex = excepts & FE_ALL_EXCEPT; 216 217 /* Store the current x87 floating-point environment */ 218 __fnstenv(&fenv); 219 220 /* Set the requested status flags */ 221 fenv.x87.status |= *flagp & ex; 222 223 /* Load the x87 floating-point environent */ 224 __fldenv(fenv); 225 226 /* Same for SSE environment */ 227 __stmxcsr(&fenv.mxcsr); 228 fenv.mxcsr |= *flagp & ex; 229 __ldmxcsr(fenv.mxcsr); 230 231 /* Success */ 232 return (0); 233 } 234 235 /* 236 * The fetestexcept() function determines which of a specified subset of the 237 * floating-point exception flags are currently set. The `excepts' argument 238 * specifies the floating-point status flags to be queried. 239 */ 240 int 241 fetestexcept(int excepts) 242 { 243 fenv_t fenv; 244 uint32_t mxcsr; 245 uint16_t status; 246 int ex; 247 248 _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0); 249 250 ex = excepts & FE_ALL_EXCEPT; 251 252 /* Store the current x87 floating-point environment */ 253 memset(&fenv, 0, sizeof(fenv)); 254 255 __fnstenv(&fenv); 256 __fnstsw(&status); 257 258 /* Store the MXCSR register state */ 259 __stmxcsr(&fenv.mxcsr); 260 __stmxcsr(&mxcsr); 261 262 return ((fenv.x87.status | fenv.mxcsr) & ex); 263 } 264 265 /* 266 * The fegetround() function gets the current rounding direction. 267 */ 268 int 269 fegetround(void) 270 { 271 uint32_t mxcsr; 272 uint16_t control; 273 274 /* 275 * We check both the x87 floating-point unit _and_ the SSE unit. 276 * Normally, those two must agree with respect to each other. If they 277 * don't, it's not our fault and the result is non-determinable, in 278 * which case POSIX says that a negative value should be returned. 279 */ 280 __fnstcw(&control); 281 __stmxcsr(&mxcsr); 282 283 if ((control & _X87_ROUNDING_MASK) 284 != ((mxcsr & _SSE_ROUNDING_MASK) >> 3)) { 285 return (-1); 286 } 287 288 return (control & _X87_ROUNDING_MASK); 289 } 290 291 /* 292 * The fesetround() function establishes the rounding direction represented by 293 * its argument `round'. If the argument is not equal to the value of a rounding 294 * direction macro, the rounding direction is not changed. 295 */ 296 int 297 fesetround(int round) 298 { 299 uint32_t mxcsr; 300 uint16_t control; 301 302 /* Check whether requested rounding direction is supported */ 303 if (round & (~_X87_ROUNDING_MASK)) 304 return (-1); 305 306 /* Store the current x87 control word register */ 307 __fnstcw(&control); 308 309 /* 310 * Set the rounding direction 311 * Rounding Control is bits 10-11, so shift appropriately 312 */ 313 control &= ~_X87_ROUNDING_MASK; 314 control |= round; 315 316 /* Load the x87 control word register */ 317 __fldcw(control); 318 319 /* 320 * Same for the SSE environment 321 * Rounding Control is bits 13-14, so shift appropriately 322 */ 323 __stmxcsr(&mxcsr); 324 mxcsr &= ~_SSE_ROUNDING_MASK; 325 mxcsr |= (round << _SSE_ROUND_SHIFT); 326 __ldmxcsr(mxcsr); 327 328 /* Success */ 329 return (0); 330 } 331 332 /* 333 * The fegetenv() function attempts to store the current floating-point 334 * environment in the object pointed to by envp. 335 */ 336 int 337 fegetenv(fenv_t *envp) 338 { 339 _DIAGASSERT(envp != NULL); 340 341 /* Store the current x87 floating-point environment */ 342 __fnstenv(envp); 343 344 /* Store the MXCSR register state */ 345 __stmxcsr(&envp->mxcsr); 346 347 /* 348 * When an FNSTENV instruction is executed, all pending exceptions are 349 * essentially lost (either the x87 FPU status register is cleared or all 350 * exceptions are masked). 351 * 352 * 8.6 X87 FPU EXCEPTION SYNCHRONIZATION - 353 * Intel(R) 64 and IA-32 Architectures Softare Developer's Manual - Vol 1 354 * 355 */ 356 __fldcw(envp->x87.control); 357 358 /* Success */ 359 return (0); 360 } 361 362 /* 363 * The feholdexcept() function saves the current floating-point environment 364 * in the object pointed to by envp, clears the floating-point status flags, and 365 * then installs a non-stop (continue on floating-point exceptions) mode, if 366 * available, for all floating-point exceptions. 367 */ 368 int 369 feholdexcept(fenv_t *envp) 370 { 371 uint32_t mxcsr; 372 373 _DIAGASSERT(envp != NULL); 374 375 /* Store the current x87 floating-point environment */ 376 __fnstenv(envp); 377 378 /* Clear all exception flags in FPU */ 379 __fnclex(); 380 381 /* Store the MXCSR register state */ 382 __stmxcsr(&envp->mxcsr); 383 384 /* Clear exception flags in MXCSR XXX */ 385 mxcsr = envp->mxcsr; 386 mxcsr &= ~FE_ALL_EXCEPT; 387 388 /* Mask all exceptions */ 389 mxcsr |= FE_ALL_EXCEPT << _SSE_EMASK_SHIFT; 390 391 __ldmxcsr(mxcsr); 392 393 /* Success */ 394 return (0); 395 } 396 397 /* 398 * The fesetenv() function attempts to establish the floating-point environment 399 * represented by the object pointed to by envp. The argument `envp' points 400 * to an object set by a call to fegetenv() or feholdexcept(), or equal a 401 * floating-point environment macro. The fesetenv() function does not raise 402 * floating-point exceptions, but only installs the state of the floating-point 403 * status flags represented through its argument. 404 */ 405 int 406 fesetenv(const fenv_t *envp) 407 { 408 fenv_t fenv; 409 410 _DIAGASSERT(envp != NULL); 411 412 /* Store the x87 floating-point environment */ 413 memset(&fenv, 0, sizeof fenv); 414 __fnstenv(&fenv); 415 416 __fe_dfl_env.x87.control = (fenv.x87.control & 0xffff0000) 417 | (__fe_dfl_env.x87.control & 0x0000ffff); 418 __fe_dfl_env.x87.status = (fenv.x87.status & 0xffff0000) 419 | (__fe_dfl_env.x87.status & 0x0000ffff); 420 __fe_dfl_env.x87.tag = (fenv.x87.tag & 0xffff0000) 421 | (__fe_dfl_env.x87.tag & 0x0000ffff); 422 __fe_dfl_env.x87.others[3] = (fenv.x87.others[3] & 0xffff0000) 423 | (__fe_dfl_env.x87.others[3] & 0x0000ffff); 424 __fldenv(*envp); 425 426 /* Store the MXCSR register */ 427 __ldmxcsr(envp->mxcsr); 428 429 /* Success */ 430 return (0); 431 } 432 433 /* 434 * The feupdateenv() function saves the currently raised floating-point 435 * exceptions in its automatic storage, installs the floating-point environment 436 * represented by the object pointed to by `envp', and then raises the saved 437 * floating-point exceptions. The argument `envp' shall point to an object set 438 * by a call to feholdexcept() or fegetenv(), or equal a floating-point 439 * environment macro. 440 */ 441 int 442 feupdateenv(const fenv_t *envp) 443 { 444 fenv_t fenv; 445 uint32_t mxcsr; 446 uint16_t sw; 447 448 _DIAGASSERT(envp != NULL); 449 450 /* Store the x87 floating-point environment */ 451 memset(&fenv, 0, sizeof(fenv)); 452 __fnstenv(&fenv); 453 454 __fe_dfl_env.x87.control = (fenv.x87.control & 0xffff0000) 455 | (__fe_dfl_env.x87.control & 0x0000ffff); 456 __fe_dfl_env.x87.status = (fenv.x87.status & 0xffff0000) 457 | (__fe_dfl_env.x87.status & 0x0000ffff); 458 __fe_dfl_env.x87.tag = (fenv.x87.tag & 0xffff0000) 459 | (__fe_dfl_env.x87.tag & 0x0000ffff); 460 __fe_dfl_env.x87.others[3] = (fenv.x87.others[3] & 0xffff0000) 461 | (__fe_dfl_env.x87.others[3] & 0x0000ffff); 462 463 /* Store the x87 status register */ 464 __fnstsw(&sw); 465 466 /* Store the MXCSR register */ 467 __stmxcsr(&mxcsr); 468 469 /* Install new floating-point environment */ 470 fesetenv(envp); 471 472 /* Raise any previously accumulated exceptions */ 473 feraiseexcept((sw | mxcsr) & FE_ALL_EXCEPT); 474 475 /* Success */ 476 return (0); 477 } 478 479 /* 480 * The following functions are extentions to the standard 481 */ 482 int 483 feenableexcept(int mask) 484 { 485 uint32_t mxcsr, omask; 486 uint16_t control; 487 488 _DIAGASSERT((mask & ~FE_ALL_EXCEPT) == 0); 489 mask &= FE_ALL_EXCEPT; 490 491 __fnstcw(&control); 492 __stmxcsr(&mxcsr); 493 494 omask = (control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; 495 control &= ~mask; 496 __fldcw(control); 497 498 mxcsr &= ~(mask << _SSE_EMASK_SHIFT); 499 __ldmxcsr(mxcsr); 500 501 return (FE_ALL_EXCEPT & ~omask); 502 503 } 504 505 int 506 fedisableexcept(int mask) 507 { 508 uint32_t mxcsr, omask; 509 uint16_t control; 510 511 _DIAGASSERT((mask & ~FE_ALL_EXCEPT) == 0); 512 513 __fnstcw(&control); 514 __stmxcsr(&mxcsr); 515 516 omask = (control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT; 517 control |= mask; 518 __fldcw(control); 519 520 mxcsr |= mask << _SSE_EMASK_SHIFT; 521 __ldmxcsr(mxcsr); 522 523 return (FE_ALL_EXCEPT & ~omask); 524 } 525 526 int 527 fegetexcept(void) 528 { 529 uint16_t control; 530 531 /* 532 * We assume that the masks for the x87 and the SSE unit are 533 * the same. 534 */ 535 __fnstcw(&control); 536 537 return (~control & FE_ALL_EXCEPT); 538 } 539 540