1 /* $OpenBSD: softfloat.h,v 1.1 2002/04/28 20:55:14 pvalchev 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 #ifndef NO_IEEE 77 78 #include <sys/types.h> 79 80 #if !defined(_KERNEL) && !defined(_STANDALONE) 81 #include <ieeefp.h> 82 #else 83 #include "machine/ieeefp.h" 84 #endif 85 #include <sys/endian.h> 86 87 /* 88 ------------------------------------------------------------------------------- 89 The macro `FLOATX80' must be defined to enable the extended double-precision 90 floating-point format `floatx80'. If this macro is not defined, the 91 `floatx80' type will not be defined, and none of the functions that either 92 input or output the `floatx80' type will be defined. The same applies to 93 the `FLOAT128' macro and the quadruple-precision format `float128'. 94 ------------------------------------------------------------------------------- 95 */ 96 /* #define FLOATX80 */ 97 /* #define FLOAT128 */ 98 99 /* 100 ------------------------------------------------------------------------------- 101 Software IEC/IEEE floating-point types. 102 ------------------------------------------------------------------------------- 103 */ 104 typedef u_int32_t float32; 105 typedef u_int64_t float64; 106 #ifdef FLOATX80 107 typedef struct { 108 #if BYTE_ORDER == BIG_ENDIAN 109 u_int16_t high; 110 u_int64_t low; 111 #else 112 u_int64_t low; 113 u_int16_t high; 114 #endif 115 } floatx80; 116 #endif 117 #ifdef FLOAT128 118 typedef struct { 119 u_int64_t high, low; 120 } float128; 121 #endif 122 123 /* 124 * Some of the global variables that used to be here have been removed for 125 * fairly obvious (defopt-MULTIPROCESSOR) reasons. The rest (which don't 126 * change dynamically) will be removed later. [ross] 127 */ 128 129 #define float_rounding_mode() fpgetround() 130 131 /* 132 ------------------------------------------------------------------------------- 133 Software IEC/IEEE floating-point underflow tininess-detection mode. 134 ------------------------------------------------------------------------------- 135 */ 136 137 extern int float_detect_tininess; 138 enum { 139 float_tininess_after_rounding = 1, 140 float_tininess_before_rounding = 0 141 }; 142 143 /* 144 ------------------------------------------------------------------------------- 145 Software IEC/IEEE floating-point rounding mode. 146 ------------------------------------------------------------------------------- 147 */ 148 149 enum { 150 float_round_nearest_even = FP_RN, 151 float_round_to_zero = FP_RZ, 152 float_round_down = FP_RM, 153 float_round_up = FP_RP 154 }; 155 156 /* 157 ------------------------------------------------------------------------------- 158 Software IEC/IEEE floating-point exception flags. 159 ------------------------------------------------------------------------------- 160 */ 161 162 enum { 163 float_flag_inexact = FP_X_IMP, 164 float_flag_underflow = FP_X_UFL, 165 float_flag_overflow = FP_X_OFL, 166 float_flag_divbyzero = FP_X_DZ, 167 float_flag_invalid = FP_X_INV 168 }; 169 170 /* 171 ------------------------------------------------------------------------------- 172 Software IEC/IEEE integer-to-floating-point conversion routines. 173 ------------------------------------------------------------------------------- 174 */ 175 float32 int32_to_float32( int ); 176 float64 int32_to_float64( int ); 177 #ifdef FLOATX80 178 floatx80 int32_to_floatx80( int ); 179 #endif 180 #ifdef FLOAT128 181 float128 int32_to_float128( int ); 182 #endif 183 #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */ 184 float32 int64_to_float32( int64_t ); 185 float64 int64_to_float64( int64_t ); 186 #ifdef FLOATX80 187 floatx80 int64_to_floatx80( int64_t ); 188 #endif 189 #ifdef FLOAT128 190 float128 int64_to_float128( int64_t ); 191 #endif 192 #endif 193 194 /* 195 ------------------------------------------------------------------------------- 196 Software IEC/IEEE single-precision conversion routines. 197 ------------------------------------------------------------------------------- 198 */ 199 int float32_to_int32( float32 ); 200 int float32_to_int32_round_to_zero( float32 ); 201 #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */ 202 int64_t float32_to_int64( float32 ); 203 int64_t float32_to_int64_round_to_zero( float32 ); 204 #endif 205 float64 float32_to_float64( float32 ); 206 #ifdef FLOATX80 207 floatx80 float32_to_floatx80( float32 ); 208 #endif 209 #ifdef FLOAT128 210 float128 float32_to_float128( float32 ); 211 #endif 212 213 /* 214 ------------------------------------------------------------------------------- 215 Software IEC/IEEE single-precision operations. 216 ------------------------------------------------------------------------------- 217 */ 218 float32 float32_round_to_int( float32 ); 219 float32 float32_add( float32, float32 ); 220 float32 float32_sub( float32, float32 ); 221 float32 float32_mul( float32, float32 ); 222 float32 float32_div( float32, float32 ); 223 float32 float32_rem( float32, float32 ); 224 float32 float32_sqrt( float32 ); 225 int float32_eq( float32, float32 ); 226 int float32_le( float32, float32 ); 227 int float32_lt( float32, float32 ); 228 int float32_eq_signaling( float32, float32 ); 229 int float32_le_quiet( float32, float32 ); 230 int float32_lt_quiet( float32, float32 ); 231 #ifndef SOFTFLOAT_FOR_GCC 232 int float32_is_signaling_nan( float32 ); 233 #endif 234 235 /* 236 ------------------------------------------------------------------------------- 237 Software IEC/IEEE double-precision conversion routines. 238 ------------------------------------------------------------------------------- 239 */ 240 int float64_to_int32( float64 ); 241 int float64_to_int32_round_to_zero( float64 ); 242 #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */ 243 int64_t float64_to_int64( float64 ); 244 int64_t float64_to_int64_round_to_zero( float64 ); 245 #endif 246 float32 float64_to_float32( float64 ); 247 #ifdef FLOATX80 248 floatx80 float64_to_floatx80( float64 ); 249 #endif 250 #ifdef FLOAT128 251 float128 float64_to_float128( float64 ); 252 #endif 253 254 /* 255 ------------------------------------------------------------------------------- 256 Software IEC/IEEE double-precision operations. 257 ------------------------------------------------------------------------------- 258 */ 259 #define float64_default_nan 0xFFF8000000000000LL 260 261 static __inline int 262 float64_is_nan(float64 a) 263 { 264 return 0xFFE0000000000000LL < a << 1; 265 } 266 267 static __inline int 268 float64_is_signaling_nan(float64 a) 269 { 270 return (a >> 51 & 0xFFF) == 0xFFE && (a & 0x0007FFFFFFFFFFFFLL); 271 } 272 273 float64 float64_round_to_int( float64 ); 274 float64 float64_add( float64, float64 ); 275 float64 float64_sub( float64, float64 ); 276 float64 float64_mul( float64, float64 ); 277 float64 float64_div( float64, float64 ); 278 float64 float64_rem( float64, float64 ); 279 float64 float64_sqrt( float64 ); 280 int float64_eq( float64, float64 ); 281 int float64_le( float64, float64 ); 282 int float64_lt( float64, float64 ); 283 int float64_eq_signaling( float64, float64 ); 284 int float64_le_quiet( float64, float64 ); 285 int float64_lt_quiet( float64, float64 ); 286 #ifndef SOFTFLOAT_FOR_GCC 287 int float64_is_signaling_nan( float64 ); 288 #endif 289 290 #ifdef FLOATX80 291 292 /* 293 ------------------------------------------------------------------------------- 294 Software IEC/IEEE extended double-precision conversion routines. 295 ------------------------------------------------------------------------------- 296 */ 297 int floatx80_to_int32( floatx80 ); 298 int floatx80_to_int32_round_to_zero( floatx80 ); 299 int64_t floatx80_to_int64( floatx80 ); 300 int64_t floatx80_to_int64_round_to_zero( floatx80 ); 301 float32 floatx80_to_float32( floatx80 ); 302 float64 floatx80_to_float64( floatx80 ); 303 #ifdef FLOAT128 304 float128 floatx80_to_float128( floatx80 ); 305 #endif 306 307 /* 308 ------------------------------------------------------------------------------- 309 Software IEC/IEEE extended double-precision rounding precision. Valid 310 values are 32, 64, and 80. 311 ------------------------------------------------------------------------------- 312 */ 313 extern int floatx80_rounding_precision; 314 315 /* 316 ------------------------------------------------------------------------------- 317 Software IEC/IEEE extended double-precision operations. 318 ------------------------------------------------------------------------------- 319 */ 320 floatx80 floatx80_round_to_int( floatx80 ); 321 floatx80 floatx80_add( floatx80, floatx80 ); 322 floatx80 floatx80_sub( floatx80, floatx80 ); 323 floatx80 floatx80_mul( floatx80, floatx80 ); 324 floatx80 floatx80_div( floatx80, floatx80 ); 325 floatx80 floatx80_rem( floatx80, floatx80 ); 326 floatx80 floatx80_sqrt( floatx80 ); 327 int floatx80_eq( floatx80, floatx80 ); 328 int floatx80_le( floatx80, floatx80 ); 329 int floatx80_lt( floatx80, floatx80 ); 330 int floatx80_eq_signaling( floatx80, floatx80 ); 331 int floatx80_le_quiet( floatx80, floatx80 ); 332 int floatx80_lt_quiet( floatx80, floatx80 ); 333 int floatx80_is_signaling_nan( floatx80 ); 334 335 #endif 336 337 #ifdef FLOAT128 338 339 /* 340 ------------------------------------------------------------------------------- 341 Software IEC/IEEE quadruple-precision conversion routines. 342 ------------------------------------------------------------------------------- 343 */ 344 int float128_to_int32( float128 ); 345 int float128_to_int32_round_to_zero( float128 ); 346 int64_t float128_to_int64( float128 ); 347 int64_t float128_to_int64_round_to_zero( float128 ); 348 float32 float128_to_float32( float128 ); 349 float64 float128_to_float64( float128 ); 350 #ifdef FLOATX80 351 floatx80 float128_to_floatx80( float128 ); 352 #endif 353 354 /* 355 ------------------------------------------------------------------------------- 356 Software IEC/IEEE quadruple-precision operations. 357 ------------------------------------------------------------------------------- 358 */ 359 float128 float128_round_to_int( float128 ); 360 float128 float128_add( float128, float128 ); 361 float128 float128_sub( float128, float128 ); 362 float128 float128_mul( float128, float128 ); 363 float128 float128_div( float128, float128 ); 364 float128 float128_rem( float128, float128 ); 365 float128 float128_sqrt( float128 ); 366 int float128_eq( float128, float128 ); 367 int float128_le( float128, float128 ); 368 int float128_lt( float128, float128 ); 369 int float128_eq_signaling( float128, float128 ); 370 int float128_le_quiet( float128, float128 ); 371 int float128_lt_quiet( float128, float128 ); 372 int float128_is_signaling_nan( float128 ); 373 374 #endif 375 376 #endif /* !NO_IEEE */ 377