Annotation of sys/lib/libkern/softfloat.h, Revision 1.1
1.1 ! nbrk 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 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to softfloat.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libkern