newlib/libm/machine/sparc/fenv.c

   1 /*      $NetBSD: fenv.c,v 1.2 2017/03/22 23:11:09 chs Exp $     */
   2
   3 /*-
   4  * Copyright (c) 2004-2005 David Schultz <das@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  */
  26 #include <sys/cdefs.h>
  27 __RCSID("$NetBSD: fenv.c,v 1.2 2017/03/22 23:11:09 chs Exp $");
  28
  29
  30
  31 #include <assert.h>
  32 #include <fenv.h>
  33
  34 #define _DIAGASSERT(x) assert(x)
  35
  36 #ifdef __weak_alias
  37 __weak_alias(feclearexcept,_feclearexcept)
  38 __weak_alias(fedisableexcept,_fedisableexcept)
  39 __weak_alias(feenableexcept,_feenableexcept)
  40 __weak_alias(fegetenv,_fegetenv)
  41 __weak_alias(fegetexcept,_fegetexcept)
  42 __weak_alias(fegetexceptflag,_fegetexceptflag)
  43 __weak_alias(fegetround,_fegetround)
  44 __weak_alias(feholdexcept,_feholdexcept)
  45 __weak_alias(feraiseexcept,_feraiseexcept)
  46 __weak_alias(fesetenv,_fesetenv)
  47 __weak_alias(fesetexceptflag,_fesetexceptflag)
  48 __weak_alias(fesetround,_fesetround)
  49 __weak_alias(fetestexcept,_fetestexcept)
  50 __weak_alias(feupdateenv,_feupdateenv)
  51 #endif
  52
  53 /* Load floating-point state register (32bits) */
  54 #define __ldfsr(__r)    __asm__ __volatile__            \
  55         ("ld %0, %%fsr" : : "m" (__r))
  56
  57 /* Save floating-point state register (32bits) */
  58 #define __stfsr(__r)    __asm__ __volatile__            \
  59         ("st %%fsr, %0" : "=m" (*(__r)))
  60
  61 /*
  62  * The feclearexcept() function clears the supported floating-point exceptions
  63  * represented by `excepts'.
  64  */
  65 int
  66 feclearexcept(int excepts)
  67 {
  68         fexcept_t r;
  69         int ex;
  70
  71         _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0);
  72
  73         ex = excepts & FE_ALL_EXCEPT;
  74
  75         __stfsr(&r);
  76         r &= ~ex;
  77         __ldfsr(r);
  78
  79         /* Success */
  80         return 0;
  81 }
  82
  83 /*
  84  * The fegetexceptflag() function stores an implementation-defined
  85  * representation of the states of the floating-point status flags indicated
  86  * by the argument excepts in the object pointed to by the argument flagp.
  87  */
  88 int
  89 fegetexceptflag(fexcept_t *flagp, int excepts)
  90 {
  91         fexcept_t r;
  92         int ex;
  93
  94         _DIAGASSERT(flagp != NULL);
  95         _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0);
  96
  97         ex = excepts & FE_ALL_EXCEPT;
  98
  99         __stfsr(&r);
 100         *flagp = r & ex;
 101
 102         /* Success */
 103         return 0;
 104 }
 105
 106
 107 /*
 108  * This function sets the floating-point status flags indicated by the argument
 109  * `excepts' to the states stored in the object pointed to by `flagp'. It does
 110  * NOT raise any floating-point exceptions, but only sets the state of the flags.
 111  */
 112 int
 113 fesetexceptflag(const fexcept_t *flagp, int excepts)
 114 {
 115         fexcept_t r;
 116         int ex;
 117
 118         _DIAGASSERT(flagp != NULL);
 119         _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0);
 120
 121         ex = excepts & FE_ALL_EXCEPT;
 122
 123         __stfsr(&r);
 124         r &= ~ex;
 125         r |= *flagp & ex;
 126         __ldfsr(r);
 127
 128         /* Success */
 129         return 0;
 130 }
 131
 132 /*
 133  * The feraiseexcept() function raises the supported floating-point exceptions
 134  * represented by the argument `excepts'.
 135  *
 136  * The order in which these floating-point exceptions are raised is unspecified
 137  * (by the standard).
 138  */
 139 int
 140 feraiseexcept(int excepts)
 141 {
 142         volatile double d;
 143         int ex;
 144
 145         _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0);
 146
 147         ex = excepts & FE_ALL_EXCEPT;
 148
 149         /*
 150          * With a compiler that supports the FENV_ACCESS pragma properly, simple
 151          * expressions like '0.0 / 0.0' should be sufficient to generate traps.
 152          * Unfortunately, we need to bring a volatile variable into the equation
 153          * to prevent incorrect optimizations.
 154          */
 155         if (ex & FE_INVALID) {
 156                 d = 0.0;
 157                 d = 0.0 / d;
 158         }
 159         if (ex & FE_DIVBYZERO) {
 160                 d = 0.0;
 161                 d = 1.0 / d;
 162         }
 163         if (ex & FE_OVERFLOW) {
 164                 d = 0x1.ffp1023;
 165                 d *= 2.0;
 166         }
 167         if (ex & FE_UNDERFLOW) {
 168                 d = 0x1p-1022;
 169                 d /= 0x1p1023;
 170         }
 171         if (ex & FE_INEXACT) {
 172                 d = 0x1p-1022;
 173                 d += 1.0;
 174         }
 175
 176         /* Success */
 177         return 0;
 178 }
 179
 180 /*
 181  * The fetestexcept() function determines which of a specified subset of the
 182  * floating-point exception flags are currently set. The `excepts' argument
 183  * specifies the floating-point status flags to be queried.
 184  */
 185 int
 186 fetestexcept(int excepts)
 187 {
 188         fexcept_t r;
 189
 190         _DIAGASSERT((excepts & ~FE_ALL_EXCEPT) == 0);
 191
 192         __stfsr(&r);
 193
 194         return r & (excepts & FE_ALL_EXCEPT);
 195 }
 196
 197 /*
 198  * The fegetround() function gets the current rounding direction.
 199  */
 200 int
 201 fegetround(void)
 202 {
 203         fenv_t r;
 204
 205         __stfsr(&r);
 206
 207         return (r >> _ROUND_SHIFT) & _ROUND_MASK;
 208 }
 209
 210 /*
 211  * The fesetround() function establishes the rounding direction represented by
 212  * its argument `round'. If the argument is not equal to the value of a rounding
 213  * direction macro, the rounding direction is not changed.
 214  */
 215 int
 216 fesetround(int round)
 217 {
 218         fenv_t r;
 219
 220         _DIAGASSERT((round & ~_ROUND_MASK) == 0);
 221         if (round & ~_ROUND_MASK)
 222                 return -1;
 223
 224         __stfsr(&r);
 225         r &= ~(_ROUND_MASK << _ROUND_SHIFT);
 226         r |= round << _ROUND_SHIFT;
 227         __ldfsr(r);
 228
 229         /* Success */
 230         return 0;
 231 }
 232
 233 /*
 234  * The fegetenv() function attempts to store the current floating-point
 235  * environment in the object pointed to by envp.
 236  */
 237 int
 238 fegetenv(fenv_t *envp)
 239 {
 240         _DIAGASSERT(envp != NULL);
 241
 242         __stfsr(envp);
 243
 244         /* Success */
 245         return 0;
 246 }
 247
 248
 249 /*
 250  * The feholdexcept() function saves the current floating-point environment
 251  * in the object pointed to by envp, clears the floating-point status flags, and
 252  * then installs a non-stop (continue on floating-point exceptions) mode, if
 253  * available, for all floating-point exceptions.
 254  */
 255 int
 256 feholdexcept(fenv_t *envp)
 257 {
 258         fenv_t r;
 259
 260         _DIAGASSERT(envp != NULL);
 261
 262         __stfsr(&r);
 263         *envp = r;
 264         r &= ~(FE_ALL_EXCEPT | _ENABLE_MASK);
 265         __ldfsr(r);
 266
 267         /* Success */
 268         return 0;
 269 }
 270
 271 /*
 272  * The fesetenv() function attempts to establish the floating-point environment
 273  * represented by the object pointed to by envp. The argument `envp' points
 274  * to an object set by a call to fegetenv() or feholdexcept(), or equal a
 275  * floating-point environment macro. The fesetenv() function does not raise
 276  * floating-point exceptions, but only installs the state of the floating-point
 277  * status flags represented through its argument.
 278  */
 279 int
 280 fesetenv(const fenv_t *envp)
 281 {
 282         _DIAGASSERT(envp != NULL);
 283
 284         __ldfsr(*envp);
 285
 286         /* Success */
 287         return 0;
 288 }
 289
 290
 291 /*
 292  * The feupdateenv() function saves the currently raised floating-point
 293  * exceptions in its automatic storage, installs the floating-point environment
 294  * represented by the object pointed to by `envp', and then raises the saved
 295  * floating-point exceptions. The argument `envp' shall point to an object set
 296  * by a call to feholdexcept() or fegetenv(), or equal a floating-point
 297  * environment macro.
 298  */
 299 int
 300 feupdateenv(const fenv_t *envp)
 301 {
 302         fexcept_t r;
 303
 304         _DIAGASSERT(envp != NULL);
 305
 306         __stfsr(&r);
 307         __ldfsr(*envp);
 308
 309         _DIAGASSERT((r & ~FE_ALL_EXCEPT) == 0);
 310         feraiseexcept(r & FE_ALL_EXCEPT);
 311
 312         /* Success */
 313         return 0;
 314 }
 315
 316 /*
 317  * The following functions are extentions to the standard
 318  */
 319 int
 320 feenableexcept(int mask)
 321 {
 322         fenv_t old_r, new_r;
 323
 324         __stfsr(&old_r);
 325         new_r = old_r | ((mask & FE_ALL_EXCEPT) << _FPUSW_SHIFT);
 326         __ldfsr(new_r);
 327
 328         return (old_r >> _FPUSW_SHIFT) & FE_ALL_EXCEPT;
 329 }
 330
 331 int
 332 fedisableexcept(int mask)
 333 {
 334         fenv_t old_r, new_r;
 335
 336         __stfsr(&old_r);
 337         new_r = old_r & ~((mask & FE_ALL_EXCEPT) << _FPUSW_SHIFT);
 338         __ldfsr(new_r);
 339
 340         return (old_r >> _FPUSW_SHIFT) & FE_ALL_EXCEPT;
 341 }
 342
 343 int
 344 fegetexcept(void)
 345 {
 346         fenv_t r;
 347
 348         __stfsr(&r);
 349         return (r & _ENABLE_MASK) >> _FPUSW_SHIFT;
 350 }