1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2004 David Schultz <das@FreeBSD.ORG> 5 * Copyright (c) 2013 Andrew Turner <andrew@FreeBSD.ORG> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 */ 31 32 #define __fenv_static 33 #include "fenv.h" 34 35 #include <machine/acle-compat.h> 36 37 #if __ARM_ARCH >= 6 38 #define FENV_ARMv6 39 #endif 40 41 /* When SOFTFP_ABI is defined we are using the softfp ABI. */ 42 #if defined(__VFP_FP__) && !defined(__ARM_PCS_VFP) 43 #define SOFTFP_ABI 44 #endif 45 46 47 #ifndef FENV_MANGLE 48 /* 49 * Hopefully the system ID byte is immutable, so it's valid to use 50 * this as a default environment. 51 */ 52 const fenv_t __fe_dfl_env = 0; 53 #endif 54 55 56 /* If this is a non-mangled softfp version special processing is required */ 57 #if defined(FENV_MANGLE) || !defined(SOFTFP_ABI) || !defined(FENV_ARMv6) 58 59 /* 60 * The following macros map between the softfloat emulator's flags and 61 * the hardware's FPSR. The hardware this file was written for doesn't 62 * have rounding control bits, so we stick those in the system ID byte. 63 */ 64 #ifndef __ARM_PCS_VFP 65 #define __set_env(env, flags, mask, rnd) env = ((flags) \ 66 | (mask)<<_FPUSW_SHIFT \ 67 | (rnd) << 24) 68 #define __env_flags(env) ((env) & FE_ALL_EXCEPT) 69 #define __env_mask(env) (((env) >> _FPUSW_SHIFT) \ 70 & FE_ALL_EXCEPT) 71 #define __env_round(env) (((env) >> 24) & _ROUND_MASK) 72 #include "fenv-softfloat.h" 73 #endif 74 75 #ifdef __GNUC_GNU_INLINE__ 76 #error "This file must be compiled with C99 'inline' semantics" 77 #endif 78 79 extern inline int feclearexcept(int __excepts); 80 extern inline int fegetexceptflag(fexcept_t *__flagp, int __excepts); 81 extern inline int fesetexceptflag(const fexcept_t *__flagp, int __excepts); 82 extern inline int feraiseexcept(int __excepts); 83 extern inline int fetestexcept(int __excepts); 84 extern inline int fegetround(void); 85 extern inline int fesetround(int __round); 86 extern inline int fegetenv(fenv_t *__envp); 87 extern inline int feholdexcept(fenv_t *__envp); 88 extern inline int fesetenv(const fenv_t *__envp); 89 extern inline int feupdateenv(const fenv_t *__envp); 90 extern inline int feenableexcept(int __mask); 91 extern inline int fedisableexcept(int __mask); 92 extern inline int fegetexcept(void); 93 94 #else /* !FENV_MANGLE && SOFTFP_ABI */ 95 /* Set by libc when the VFP unit is enabled */ 96 extern int _libc_arm_fpu_present; 97 98 int __softfp_feclearexcept(int __excepts); 99 int __softfp_fegetexceptflag(fexcept_t *__flagp, int __excepts); 100 int __softfp_fesetexceptflag(const fexcept_t *__flagp, int __excepts); 101 int __softfp_feraiseexcept(int __excepts); 102 int __softfp_fetestexcept(int __excepts); 103 int __softfp_fegetround(void); 104 int __softfp_fesetround(int __round); 105 int __softfp_fegetenv(fenv_t *__envp); 106 int __softfp_feholdexcept(fenv_t *__envp); 107 int __softfp_fesetenv(const fenv_t *__envp); 108 int __softfp_feupdateenv(const fenv_t *__envp); 109 int __softfp_feenableexcept(int __mask); 110 int __softfp_fedisableexcept(int __mask); 111 int __softfp_fegetexcept(void); 112 113 int __vfp_feclearexcept(int __excepts); 114 int __vfp_fegetexceptflag(fexcept_t *__flagp, int __excepts); 115 int __vfp_fesetexceptflag(const fexcept_t *__flagp, int __excepts); 116 int __vfp_feraiseexcept(int __excepts); 117 int __vfp_fetestexcept(int __excepts); 118 int __vfp_fegetround(void); 119 int __vfp_fesetround(int __round); 120 int __vfp_fegetenv(fenv_t *__envp); 121 int __vfp_feholdexcept(fenv_t *__envp); 122 int __vfp_fesetenv(const fenv_t *__envp); 123 int __vfp_feupdateenv(const fenv_t *__envp); 124 int __vfp_feenableexcept(int __mask); 125 int __vfp_fedisableexcept(int __mask); 126 int __vfp_fegetexcept(void); 127 128 static int 129 __softfp_round_to_vfp(int round) 130 { 131 132 switch (round) { 133 case FE_TONEAREST: 134 default: 135 return VFP_FE_TONEAREST; 136 case FE_TOWARDZERO: 137 return VFP_FE_TOWARDZERO; 138 case FE_UPWARD: 139 return VFP_FE_UPWARD; 140 case FE_DOWNWARD: 141 return VFP_FE_DOWNWARD; 142 } 143 } 144 145 static int 146 __softfp_round_from_vfp(int round) 147 { 148 149 switch (round) { 150 case VFP_FE_TONEAREST: 151 default: 152 return FE_TONEAREST; 153 case VFP_FE_TOWARDZERO: 154 return FE_TOWARDZERO; 155 case VFP_FE_UPWARD: 156 return FE_UPWARD; 157 case VFP_FE_DOWNWARD: 158 return FE_DOWNWARD; 159 } 160 } 161 162 int feclearexcept(int __excepts) 163 { 164 165 if (_libc_arm_fpu_present) 166 __vfp_feclearexcept(__excepts); 167 __softfp_feclearexcept(__excepts); 168 169 return (0); 170 } 171 172 int fegetexceptflag(fexcept_t *__flagp, int __excepts) 173 { 174 fexcept_t __vfp_flagp; 175 176 __vfp_flagp = 0; 177 if (_libc_arm_fpu_present) 178 __vfp_fegetexceptflag(&__vfp_flagp, __excepts); 179 __softfp_fegetexceptflag(__flagp, __excepts); 180 181 *__flagp |= __vfp_flagp; 182 183 return (0); 184 } 185 186 int fesetexceptflag(const fexcept_t *__flagp, int __excepts) 187 { 188 189 if (_libc_arm_fpu_present) 190 __vfp_fesetexceptflag(__flagp, __excepts); 191 __softfp_fesetexceptflag(__flagp, __excepts); 192 193 return (0); 194 } 195 196 int feraiseexcept(int __excepts) 197 { 198 199 if (_libc_arm_fpu_present) 200 __vfp_feraiseexcept(__excepts); 201 __softfp_feraiseexcept(__excepts); 202 203 return (0); 204 } 205 206 int fetestexcept(int __excepts) 207 { 208 int __got_excepts; 209 210 __got_excepts = 0; 211 if (_libc_arm_fpu_present) 212 __got_excepts = __vfp_fetestexcept(__excepts); 213 __got_excepts |= __softfp_fetestexcept(__excepts); 214 215 return (__got_excepts); 216 } 217 218 int fegetround(void) 219 { 220 221 if (_libc_arm_fpu_present) 222 return __softfp_round_from_vfp(__vfp_fegetround()); 223 return __softfp_fegetround(); 224 } 225 226 int fesetround(int __round) 227 { 228 229 if (_libc_arm_fpu_present) 230 __vfp_fesetround(__softfp_round_to_vfp(__round)); 231 __softfp_fesetround(__round); 232 233 return (0); 234 } 235 236 int fegetenv(fenv_t *__envp) 237 { 238 fenv_t __vfp_envp; 239 240 __vfp_envp = 0; 241 if (_libc_arm_fpu_present) 242 __vfp_fegetenv(&__vfp_envp); 243 __softfp_fegetenv(__envp); 244 *__envp |= __vfp_envp; 245 246 return (0); 247 } 248 249 int feholdexcept(fenv_t *__envp) 250 { 251 fenv_t __vfp_envp; 252 253 __vfp_envp = 0; 254 if (_libc_arm_fpu_present) 255 __vfp_feholdexcept(&__vfp_envp); 256 __softfp_feholdexcept(__envp); 257 *__envp |= __vfp_envp; 258 259 return (0); 260 } 261 262 int fesetenv(const fenv_t *__envp) 263 { 264 265 if (_libc_arm_fpu_present) 266 __vfp_fesetenv(__envp); 267 __softfp_fesetenv(__envp); 268 269 return (0); 270 } 271 272 int feupdateenv(const fenv_t *__envp) 273 { 274 275 if (_libc_arm_fpu_present) 276 __vfp_feupdateenv(__envp); 277 __softfp_feupdateenv(__envp); 278 279 return (0); 280 } 281 282 int feenableexcept(int __mask) 283 { 284 int __unmasked; 285 286 __unmasked = 0; 287 if (_libc_arm_fpu_present) 288 __unmasked = __vfp_feenableexcept(__mask); 289 __unmasked |= __softfp_feenableexcept(__mask); 290 291 return (__unmasked); 292 } 293 294 int fedisableexcept(int __mask) 295 { 296 int __unmasked; 297 298 __unmasked = 0; 299 if (_libc_arm_fpu_present) 300 __unmasked = __vfp_fedisableexcept(__mask); 301 __unmasked |= __softfp_fedisableexcept(__mask); 302 303 return (__unmasked); 304 } 305 306 int fegetexcept(void) 307 { 308 int __unmasked; 309 310 __unmasked = 0; 311 if (_libc_arm_fpu_present) 312 __unmasked = __vfp_fegetexcept(); 313 __unmasked |= __softfp_fegetexcept(); 314 315 return (__unmasked); 316 } 317 318 #endif 319 320