1 /* $OpenBSD: softfloat.h,v 1.2 2007/12/29 16:59:16 miod Exp $ */ 2 /* $NetBSD: softfloat.h,v 1.1 2001/04/26 03:10:48 ross Exp $ */ 3 4 /* This is a derivative work. */ 5 6 /*- 7 * Copyright (c) 2001 The NetBSD Foundation, Inc. 8 * All rights reserved. 9 * 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by Ross Harvey. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. All advertising materials mentioning features or use of this software 22 * must display the following acknowledgement: 23 * This product includes software developed by the NetBSD 24 * Foundation, Inc. and its contributors. 25 * 4. Neither the name of The NetBSD Foundation nor the names of its 26 * contributors may be used to endorse or promote products derived 27 * from this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 30 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 31 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 32 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 33 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 34 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 35 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 36 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 37 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 38 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 39 * POSSIBILITY OF SUCH DAMAGE. 40 */ 41 42 /* 43 =============================================================================== 44 45 This C header file is part of the SoftFloat IEC/IEEE Floating-point 46 Arithmetic Package, Release 2a. 47 48 Written by John R. Hauser. This work was made possible in part by the 49 International Computer Science Institute, located at Suite 600, 1947 Center 50 Street, Berkeley, California 94704. Funding was partially provided by the 51 National Science Foundation under grant MIP-9311980. The original version 52 of this code was written as part of a project to build a fixed-point vector 53 processor in collaboration with the University of California at Berkeley, 54 overseen by Profs. Nelson Morgan and John Wawrzynek. More information 55 is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ 56 arithmetic/SoftFloat.html'. 57 58 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable 59 effort has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT 60 WILL AT TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS 61 RESTRICTED TO PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL 62 RESPONSIBILITY FOR ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM 63 THEIR OWN USE OF THE SOFTWARE, AND WHO ALSO EFFECTIVELY INDEMNIFY 64 (possibly via similar legal warning) JOHN HAUSER AND THE INTERNATIONAL 65 COMPUTER SCIENCE INSTITUTE AGAINST ALL LOSSES, COSTS, OR OTHER PROBLEMS 66 ARISING FROM THE USE OF THE SOFTWARE BY THEIR CUSTOMERS AND CLIENTS. 67 68 Derivative works are acceptable, even for commercial purposes, so long as 69 (1) they include prominent notice that the work is derivative, and (2) they 70 include prominent notice akin to these four paragraphs for those parts of 71 this code that are retained. 72 73 =============================================================================== 74 */ 75 76 #include <sys/types.h> 77 78 #if !defined(_KERNEL) && !defined(_STANDALONE) 79 #include <ieeefp.h> 80 #else 81 #include "machine/ieeefp.h" 82 #endif 83 #include <sys/endian.h> 84 85 /* 86 ------------------------------------------------------------------------------- 87 The macro `FLOATX80' must be defined to enable the extended double-precision 88 floating-point format `floatx80'. If this macro is not defined, the 89 `floatx80' type will not be defined, and none of the functions that either 90 input or output the `floatx80' type will be defined. The same applies to 91 the `FLOAT128' macro and the quadruple-precision format `float128'. 92 ------------------------------------------------------------------------------- 93 */ 94 /* #define FLOATX80 */ 95 /* #define FLOAT128 */ 96 97 /* 98 ------------------------------------------------------------------------------- 99 Software IEC/IEEE floating-point types. 100 ------------------------------------------------------------------------------- 101 */ 102 typedef u_int32_t float32; 103 typedef u_int64_t float64; 104 #ifdef FLOATX80 105 typedef struct { 106 #if BYTE_ORDER == BIG_ENDIAN 107 u_int16_t high; 108 u_int64_t low; 109 #else 110 u_int64_t low; 111 u_int16_t high; 112 #endif 113 } floatx80; 114 #endif 115 #ifdef FLOAT128 116 typedef struct { 117 u_int64_t high, low; 118 } float128; 119 #endif 120 121 /* 122 * Some of the global variables that used to be here have been removed for 123 * fairly obvious (defopt-MULTIPROCESSOR) reasons. The rest (which don't 124 * change dynamically) will be removed later. [ross] 125 */ 126 127 #define float_rounding_mode() fpgetround() 128 129 /* 130 ------------------------------------------------------------------------------- 131 Software IEC/IEEE floating-point underflow tininess-detection mode. 132 ------------------------------------------------------------------------------- 133 */ 134 135 extern int float_detect_tininess; 136 enum { 137 float_tininess_after_rounding = 1, 138 float_tininess_before_rounding = 0 139 }; 140 141 /* 142 ------------------------------------------------------------------------------- 143 Software IEC/IEEE floating-point rounding mode. 144 ------------------------------------------------------------------------------- 145 */ 146 147 enum { 148 float_round_nearest_even = FP_RN, 149 float_round_to_zero = FP_RZ, 150 float_round_down = FP_RM, 151 float_round_up = FP_RP 152 }; 153 154 /* 155 ------------------------------------------------------------------------------- 156 Software IEC/IEEE floating-point exception flags. 157 ------------------------------------------------------------------------------- 158 */ 159 160 enum { 161 float_flag_inexact = FP_X_IMP, 162 float_flag_underflow = FP_X_UFL, 163 float_flag_overflow = FP_X_OFL, 164 float_flag_divbyzero = FP_X_DZ, 165 float_flag_invalid = FP_X_INV 166 }; 167 168 /* 169 ------------------------------------------------------------------------------- 170 Software IEC/IEEE integer-to-floating-point conversion routines. 171 ------------------------------------------------------------------------------- 172 */ 173 float32 int32_to_float32( int ); 174 float64 int32_to_float64( int ); 175 #ifdef FLOATX80 176 floatx80 int32_to_floatx80( int ); 177 #endif 178 #ifdef FLOAT128 179 float128 int32_to_float128( int ); 180 #endif 181 #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */ 182 float32 int64_to_float32( int64_t ); 183 float64 int64_to_float64( int64_t ); 184 #ifdef FLOATX80 185 floatx80 int64_to_floatx80( int64_t ); 186 #endif 187 #ifdef FLOAT128 188 float128 int64_to_float128( int64_t ); 189 #endif 190 #endif 191 192 /* 193 ------------------------------------------------------------------------------- 194 Software IEC/IEEE single-precision conversion routines. 195 ------------------------------------------------------------------------------- 196 */ 197 int float32_to_int32( float32 ); 198 int float32_to_int32_round_to_zero( float32 ); 199 #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */ 200 int64_t float32_to_int64( float32 ); 201 int64_t float32_to_int64_round_to_zero( float32 ); 202 #endif 203 float64 float32_to_float64( float32 ); 204 #ifdef FLOATX80 205 floatx80 float32_to_floatx80( float32 ); 206 #endif 207 #ifdef FLOAT128 208 float128 float32_to_float128( float32 ); 209 #endif 210 211 /* 212 ------------------------------------------------------------------------------- 213 Software IEC/IEEE single-precision operations. 214 ------------------------------------------------------------------------------- 215 */ 216 float32 float32_round_to_int( float32 ); 217 float32 float32_add( float32, float32 ); 218 float32 float32_sub( float32, float32 ); 219 float32 float32_mul( float32, float32 ); 220 float32 float32_div( float32, float32 ); 221 float32 float32_rem( float32, float32 ); 222 float32 float32_sqrt( float32 ); 223 int float32_eq( float32, float32 ); 224 int float32_le( float32, float32 ); 225 int float32_lt( float32, float32 ); 226 int float32_eq_signaling( float32, float32 ); 227 int float32_le_quiet( float32, float32 ); 228 int float32_lt_quiet( float32, float32 ); 229 #ifndef SOFTFLOAT_FOR_GCC 230 int float32_is_signaling_nan( float32 ); 231 #endif 232 233 /* 234 ------------------------------------------------------------------------------- 235 Software IEC/IEEE double-precision conversion routines. 236 ------------------------------------------------------------------------------- 237 */ 238 int float64_to_int32( float64 ); 239 int float64_to_int32_round_to_zero( float64 ); 240 #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */ 241 int64_t float64_to_int64( float64 ); 242 int64_t float64_to_int64_round_to_zero( float64 ); 243 #endif 244 float32 float64_to_float32( float64 ); 245 #ifdef FLOATX80 246 floatx80 float64_to_floatx80( float64 ); 247 #endif 248 #ifdef FLOAT128 249 float128 float64_to_float128( float64 ); 250 #endif 251 252 /* 253 ------------------------------------------------------------------------------- 254 Software IEC/IEEE double-precision operations. 255 ------------------------------------------------------------------------------- 256 */ 257 #define float64_default_nan 0xFFF8000000000000LL 258 259 static __inline int 260 float64_is_nan(float64 a) 261 { 262 return 0xFFE0000000000000LL < a << 1; 263 } 264 265 static __inline int 266 float64_is_signaling_nan(float64 a) 267 { 268 return (a >> 51 & 0xFFF) == 0xFFE && (a & 0x0007FFFFFFFFFFFFLL); 269 } 270 271 float64 float64_round_to_int( float64 ); 272 float64 float64_add( float64, float64 ); 273 float64 float64_sub( float64, float64 ); 274 float64 float64_mul( float64, float64 ); 275 float64 float64_div( float64, float64 ); 276 float64 float64_rem( float64, float64 ); 277 float64 float64_sqrt( float64 ); 278 int float64_eq( float64, float64 ); 279 int float64_le( float64, float64 ); 280 int float64_lt( float64, float64 ); 281 int float64_eq_signaling( float64, float64 ); 282 int float64_le_quiet( float64, float64 ); 283 int float64_lt_quiet( float64, float64 ); 284 #ifndef SOFTFLOAT_FOR_GCC 285 int float64_is_signaling_nan( float64 ); 286 #endif 287 288 #ifdef FLOATX80 289 290 /* 291 ------------------------------------------------------------------------------- 292 Software IEC/IEEE extended double-precision conversion routines. 293 ------------------------------------------------------------------------------- 294 */ 295 int floatx80_to_int32( floatx80 ); 296 int floatx80_to_int32_round_to_zero( floatx80 ); 297 int64_t floatx80_to_int64( floatx80 ); 298 int64_t floatx80_to_int64_round_to_zero( floatx80 ); 299 float32 floatx80_to_float32( floatx80 ); 300 float64 floatx80_to_float64( floatx80 ); 301 #ifdef FLOAT128 302 float128 floatx80_to_float128( floatx80 ); 303 #endif 304 305 /* 306 ------------------------------------------------------------------------------- 307 Software IEC/IEEE extended double-precision rounding precision. Valid 308 values are 32, 64, and 80. 309 ------------------------------------------------------------------------------- 310 */ 311 extern int floatx80_rounding_precision; 312 313 /* 314 ------------------------------------------------------------------------------- 315 Software IEC/IEEE extended double-precision operations. 316 ------------------------------------------------------------------------------- 317 */ 318 floatx80 floatx80_round_to_int( floatx80 ); 319 floatx80 floatx80_add( floatx80, floatx80 ); 320 floatx80 floatx80_sub( floatx80, floatx80 ); 321 floatx80 floatx80_mul( floatx80, floatx80 ); 322 floatx80 floatx80_div( floatx80, floatx80 ); 323 floatx80 floatx80_rem( floatx80, floatx80 ); 324 floatx80 floatx80_sqrt( floatx80 ); 325 int floatx80_eq( floatx80, floatx80 ); 326 int floatx80_le( floatx80, floatx80 ); 327 int floatx80_lt( floatx80, floatx80 ); 328 int floatx80_eq_signaling( floatx80, floatx80 ); 329 int floatx80_le_quiet( floatx80, floatx80 ); 330 int floatx80_lt_quiet( floatx80, floatx80 ); 331 int floatx80_is_signaling_nan( floatx80 ); 332 333 #endif 334 335 #ifdef FLOAT128 336 337 /* 338 ------------------------------------------------------------------------------- 339 Software IEC/IEEE quadruple-precision conversion routines. 340 ------------------------------------------------------------------------------- 341 */ 342 int float128_to_int32( float128 ); 343 int float128_to_int32_round_to_zero( float128 ); 344 int64_t float128_to_int64( float128 ); 345 int64_t float128_to_int64_round_to_zero( float128 ); 346 float32 float128_to_float32( float128 ); 347 float64 float128_to_float64( float128 ); 348 #ifdef FLOATX80 349 floatx80 float128_to_floatx80( float128 ); 350 #endif 351 352 /* 353 ------------------------------------------------------------------------------- 354 Software IEC/IEEE quadruple-precision operations. 355 ------------------------------------------------------------------------------- 356 */ 357 float128 float128_round_to_int( float128 ); 358 float128 float128_add( float128, float128 ); 359 float128 float128_sub( float128, float128 ); 360 float128 float128_mul( float128, float128 ); 361 float128 float128_div( float128, float128 ); 362 float128 float128_rem( float128, float128 ); 363 float128 float128_sqrt( float128 ); 364 int float128_eq( float128, float128 ); 365 int float128_le( float128, float128 ); 366 int float128_lt( float128, float128 ); 367 int float128_eq_signaling( float128, float128 ); 368 int float128_le_quiet( float128, float128 ); 369 int float128_lt_quiet( float128, float128 ); 370 int float128_is_signaling_nan( float128 ); 371 372 #endif 373