1*ce099b40Smartin /* $NetBSD: softfloat.h,v 1.5 2008/04/28 20:23:04 martin Exp $ */ 28b75248bSross 38b75248bSross /* This is a derivative work. */ 48b75248bSross 58b75248bSross /*- 68b75248bSross * Copyright (c) 2001 The NetBSD Foundation, Inc. 78b75248bSross * All rights reserved. 88b75248bSross * 98b75248bSross * This code is derived from software contributed to The NetBSD Foundation 108b75248bSross * by Ross Harvey. 118b75248bSross * 128b75248bSross * Redistribution and use in source and binary forms, with or without 138b75248bSross * modification, are permitted provided that the following conditions 148b75248bSross * are met: 158b75248bSross * 1. Redistributions of source code must retain the above copyright 168b75248bSross * notice, this list of conditions and the following disclaimer. 178b75248bSross * 2. Redistributions in binary form must reproduce the above copyright 188b75248bSross * notice, this list of conditions and the following disclaimer in the 198b75248bSross * documentation and/or other materials provided with the distribution. 208b75248bSross * 218b75248bSross * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 228b75248bSross * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 238b75248bSross * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 248b75248bSross * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 258b75248bSross * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 268b75248bSross * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 278b75248bSross * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 288b75248bSross * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 298b75248bSross * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 308b75248bSross * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 318b75248bSross * POSSIBILITY OF SUCH DAMAGE. 328b75248bSross */ 338b75248bSross 348b75248bSross /* 358b75248bSross =============================================================================== 368b75248bSross 378b75248bSross This C header file is part of the SoftFloat IEC/IEEE Floating-point 388b75248bSross Arithmetic Package, Release 2a. 398b75248bSross 408b75248bSross Written by John R. Hauser. This work was made possible in part by the 418b75248bSross International Computer Science Institute, located at Suite 600, 1947 Center 428b75248bSross Street, Berkeley, California 94704. Funding was partially provided by the 438b75248bSross National Science Foundation under grant MIP-9311980. The original version 448b75248bSross of this code was written as part of a project to build a fixed-point vector 458b75248bSross processor in collaboration with the University of California at Berkeley, 468b75248bSross overseen by Profs. Nelson Morgan and John Wawrzynek. More information 478b75248bSross is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ 488b75248bSross arithmetic/SoftFloat.html'. 498b75248bSross 508b75248bSross THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 518b75248bSross has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 528b75248bSross TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 538b75248bSross PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 548b75248bSross AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 558b75248bSross 568b75248bSross Derivative works are acceptable, even for commercial purposes, so long as 578b75248bSross (1) they include prominent notice that the work is derivative, and (2) they 588b75248bSross include prominent notice akin to these four paragraphs for those parts of 598b75248bSross this code that are retained. 608b75248bSross 618b75248bSross =============================================================================== 628b75248bSross */ 638b75248bSross 648b75248bSross #include <ieeefp.h> 658b75248bSross #include <inttypes.h> 668b75248bSross #include <sys/endian.h> 678b75248bSross 688b75248bSross /* 698b75248bSross ------------------------------------------------------------------------------- 708b75248bSross The macro `FLOATX80' must be defined to enable the extended double-precision 718b75248bSross floating-point format `floatx80'. If this macro is not defined, the 728b75248bSross `floatx80' type will not be defined, and none of the functions that either 738b75248bSross input or output the `floatx80' type will be defined. The same applies to 748b75248bSross the `FLOAT128' macro and the quadruple-precision format `float128'. 758b75248bSross ------------------------------------------------------------------------------- 768b75248bSross */ 778b75248bSross /* #define FLOATX80 */ 788b75248bSross /* #define FLOAT128 */ 798b75248bSross 808b75248bSross /* 818b75248bSross ------------------------------------------------------------------------------- 828b75248bSross Software IEC/IEEE floating-point types. 838b75248bSross ------------------------------------------------------------------------------- 848b75248bSross */ 85a41c3721Sross typedef uint32_t float32; 86a41c3721Sross typedef uint64_t float64; 878b75248bSross #ifdef FLOATX80 888b75248bSross typedef struct { 898b75248bSross #if BYTE_ORDER == BIG_ENDIAN 90a41c3721Sross uint16_t high; 91a41c3721Sross uint64_t low; 928b75248bSross #else 93a41c3721Sross uint64_t low; 94a41c3721Sross uint16_t high; 958b75248bSross #endif 968b75248bSross } floatx80; 978b75248bSross #endif 988b75248bSross #ifdef FLOAT128 998b75248bSross typedef struct { 100a41c3721Sross uint64_t high, low; 1018b75248bSross } float128; 1028b75248bSross #endif 1038b75248bSross 1048b75248bSross /* 1058b75248bSross ------------------------------------------------------------------------------- 1068b75248bSross Software IEC/IEEE floating-point underflow tininess-detection mode. 1078b75248bSross ------------------------------------------------------------------------------- 1088b75248bSross */ 1098b75248bSross extern int float_detect_tininess; 1108b75248bSross enum { 1118b75248bSross float_tininess_after_rounding = 0, 1128b75248bSross float_tininess_before_rounding = 1 1138b75248bSross }; 1148b75248bSross 1158b75248bSross /* 1168b75248bSross ------------------------------------------------------------------------------- 1178b75248bSross Software IEC/IEEE floating-point rounding mode. 1188b75248bSross ------------------------------------------------------------------------------- 1198b75248bSross */ 1208f63ecd3Sbjh21 extern fp_rnd float_rounding_mode; 1218b75248bSross enum { 1228b75248bSross float_round_nearest_even = FP_RN, 1238b75248bSross float_round_to_zero = FP_RZ, 1248b75248bSross float_round_down = FP_RM, 1258b75248bSross float_round_up = FP_RP 1268b75248bSross }; 1278b75248bSross 1288b75248bSross /* 1298b75248bSross ------------------------------------------------------------------------------- 1308b75248bSross Software IEC/IEEE floating-point exception flags. 1318b75248bSross ------------------------------------------------------------------------------- 1328b75248bSross */ 1338f63ecd3Sbjh21 extern fp_except float_exception_flags; 1348b75248bSross enum { 1358b75248bSross float_flag_inexact = FP_X_IMP, 1368b75248bSross float_flag_underflow = FP_X_UFL, 1378b75248bSross float_flag_overflow = FP_X_OFL, 1388b75248bSross float_flag_divbyzero = FP_X_DZ, 1398b75248bSross float_flag_invalid = FP_X_INV 1408b75248bSross }; 1418b75248bSross 1428b75248bSross /* 1438b75248bSross ------------------------------------------------------------------------------- 1448b75248bSross Routine to raise any or all of the software IEC/IEEE floating-point 1458b75248bSross exception flags. 1468b75248bSross ------------------------------------------------------------------------------- 1478b75248bSross */ 1488b75248bSross void float_raise( int ); 1498b75248bSross 1508b75248bSross /* 1518b75248bSross ------------------------------------------------------------------------------- 1528b75248bSross Software IEC/IEEE integer-to-floating-point conversion routines. 1538b75248bSross ------------------------------------------------------------------------------- 1548b75248bSross */ 1558b75248bSross float32 int32_to_float32( int ); 1568b75248bSross float64 int32_to_float64( int ); 1578b75248bSross #ifdef FLOATX80 1588b75248bSross floatx80 int32_to_floatx80( int ); 1598b75248bSross #endif 1608b75248bSross #ifdef FLOAT128 1618b75248bSross float128 int32_to_float128( int ); 1628b75248bSross #endif 1638b75248bSross #ifndef SOFTFLOAT_FOR_GCC /* __floatdi?f is in libgcc2.c */ 1648b75248bSross float32 int64_to_float32( int64_t ); 1658b75248bSross float64 int64_to_float64( int64_t ); 1668b75248bSross #ifdef FLOATX80 1678b75248bSross floatx80 int64_to_floatx80( int64_t ); 1688b75248bSross #endif 1698b75248bSross #ifdef FLOAT128 1708b75248bSross float128 int64_to_float128( int64_t ); 1718b75248bSross #endif 1728b75248bSross #endif 1738b75248bSross 1748b75248bSross /* 1758b75248bSross ------------------------------------------------------------------------------- 1768b75248bSross Software IEC/IEEE single-precision conversion routines. 1778b75248bSross ------------------------------------------------------------------------------- 1788b75248bSross */ 1798b75248bSross int float32_to_int32( float32 ); 1808b75248bSross int float32_to_int32_round_to_zero( float32 ); 1818b75248bSross #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */ 1828b75248bSross int64_t float32_to_int64( float32 ); 1838b75248bSross int64_t float32_to_int64_round_to_zero( float32 ); 1848b75248bSross #endif 1858b75248bSross float64 float32_to_float64( float32 ); 1868b75248bSross #ifdef FLOATX80 1878b75248bSross floatx80 float32_to_floatx80( float32 ); 1888b75248bSross #endif 1898b75248bSross #ifdef FLOAT128 1908b75248bSross float128 float32_to_float128( float32 ); 1918b75248bSross #endif 1928b75248bSross 1938b75248bSross /* 1948b75248bSross ------------------------------------------------------------------------------- 1958b75248bSross Software IEC/IEEE single-precision operations. 1968b75248bSross ------------------------------------------------------------------------------- 1978b75248bSross */ 1988b75248bSross float32 float32_round_to_int( float32 ); 1998b75248bSross float32 float32_add( float32, float32 ); 2008b75248bSross float32 float32_sub( float32, float32 ); 2018b75248bSross float32 float32_mul( float32, float32 ); 2028b75248bSross float32 float32_div( float32, float32 ); 2038b75248bSross float32 float32_rem( float32, float32 ); 2048b75248bSross float32 float32_sqrt( float32 ); 2058b75248bSross int float32_eq( float32, float32 ); 2068b75248bSross int float32_le( float32, float32 ); 2078b75248bSross int float32_lt( float32, float32 ); 2088b75248bSross int float32_eq_signaling( float32, float32 ); 2098b75248bSross int float32_le_quiet( float32, float32 ); 2108b75248bSross int float32_lt_quiet( float32, float32 ); 2118b75248bSross #ifndef SOFTFLOAT_FOR_GCC 2128b75248bSross int float32_is_signaling_nan( float32 ); 2138b75248bSross #endif 2148b75248bSross 2158b75248bSross /* 2168b75248bSross ------------------------------------------------------------------------------- 2178b75248bSross Software IEC/IEEE double-precision conversion routines. 2188b75248bSross ------------------------------------------------------------------------------- 2198b75248bSross */ 2208b75248bSross int float64_to_int32( float64 ); 2218b75248bSross int float64_to_int32_round_to_zero( float64 ); 2228b75248bSross #ifndef SOFTFLOAT_FOR_GCC /* __fix?fdi provided by libgcc2.c */ 2238b75248bSross int64_t float64_to_int64( float64 ); 2248b75248bSross int64_t float64_to_int64_round_to_zero( float64 ); 2258b75248bSross #endif 2268b75248bSross float32 float64_to_float32( float64 ); 2278b75248bSross #ifdef FLOATX80 2288b75248bSross floatx80 float64_to_floatx80( float64 ); 2298b75248bSross #endif 2308b75248bSross #ifdef FLOAT128 2318b75248bSross float128 float64_to_float128( float64 ); 2328b75248bSross #endif 2338b75248bSross 2348b75248bSross /* 2358b75248bSross ------------------------------------------------------------------------------- 2368b75248bSross Software IEC/IEEE double-precision operations. 2378b75248bSross ------------------------------------------------------------------------------- 2388b75248bSross */ 2398b75248bSross float64 float64_round_to_int( float64 ); 2408b75248bSross float64 float64_add( float64, float64 ); 2418b75248bSross float64 float64_sub( float64, float64 ); 2428b75248bSross float64 float64_mul( float64, float64 ); 2438b75248bSross float64 float64_div( float64, float64 ); 2448b75248bSross float64 float64_rem( float64, float64 ); 2458b75248bSross float64 float64_sqrt( float64 ); 2468b75248bSross int float64_eq( float64, float64 ); 2478b75248bSross int float64_le( float64, float64 ); 2488b75248bSross int float64_lt( float64, float64 ); 2498b75248bSross int float64_eq_signaling( float64, float64 ); 2508b75248bSross int float64_le_quiet( float64, float64 ); 2518b75248bSross int float64_lt_quiet( float64, float64 ); 2528b75248bSross #ifndef SOFTFLOAT_FOR_GCC 2538b75248bSross int float64_is_signaling_nan( float64 ); 2548b75248bSross #endif 2558b75248bSross 2568b75248bSross #ifdef FLOATX80 2578b75248bSross 2588b75248bSross /* 2598b75248bSross ------------------------------------------------------------------------------- 2608b75248bSross Software IEC/IEEE extended double-precision conversion routines. 2618b75248bSross ------------------------------------------------------------------------------- 2628b75248bSross */ 2638b75248bSross int floatx80_to_int32( floatx80 ); 2648b75248bSross int floatx80_to_int32_round_to_zero( floatx80 ); 2658b75248bSross int64_t floatx80_to_int64( floatx80 ); 2668b75248bSross int64_t floatx80_to_int64_round_to_zero( floatx80 ); 2678b75248bSross float32 floatx80_to_float32( floatx80 ); 2688b75248bSross float64 floatx80_to_float64( floatx80 ); 2698b75248bSross #ifdef FLOAT128 2708b75248bSross float128 floatx80_to_float128( floatx80 ); 2718b75248bSross #endif 2728b75248bSross 2738b75248bSross /* 2748b75248bSross ------------------------------------------------------------------------------- 2758b75248bSross Software IEC/IEEE extended double-precision rounding precision. Valid 2768b75248bSross values are 32, 64, and 80. 2778b75248bSross ------------------------------------------------------------------------------- 2788b75248bSross */ 2798b75248bSross extern int floatx80_rounding_precision; 2808b75248bSross 2818b75248bSross /* 2828b75248bSross ------------------------------------------------------------------------------- 2838b75248bSross Software IEC/IEEE extended double-precision operations. 2848b75248bSross ------------------------------------------------------------------------------- 2858b75248bSross */ 2868b75248bSross floatx80 floatx80_round_to_int( floatx80 ); 2878b75248bSross floatx80 floatx80_add( floatx80, floatx80 ); 2888b75248bSross floatx80 floatx80_sub( floatx80, floatx80 ); 2898b75248bSross floatx80 floatx80_mul( floatx80, floatx80 ); 2908b75248bSross floatx80 floatx80_div( floatx80, floatx80 ); 2918b75248bSross floatx80 floatx80_rem( floatx80, floatx80 ); 2928b75248bSross floatx80 floatx80_sqrt( floatx80 ); 2938b75248bSross int floatx80_eq( floatx80, floatx80 ); 2948b75248bSross int floatx80_le( floatx80, floatx80 ); 2958b75248bSross int floatx80_lt( floatx80, floatx80 ); 2968b75248bSross int floatx80_eq_signaling( floatx80, floatx80 ); 2978b75248bSross int floatx80_le_quiet( floatx80, floatx80 ); 2988b75248bSross int floatx80_lt_quiet( floatx80, floatx80 ); 2998b75248bSross int floatx80_is_signaling_nan( floatx80 ); 3008b75248bSross 3018b75248bSross #endif 3028b75248bSross 3038b75248bSross #ifdef FLOAT128 3048b75248bSross 3058b75248bSross /* 3068b75248bSross ------------------------------------------------------------------------------- 3078b75248bSross Software IEC/IEEE quadruple-precision conversion routines. 3088b75248bSross ------------------------------------------------------------------------------- 3098b75248bSross */ 3108b75248bSross int float128_to_int32( float128 ); 3118b75248bSross int float128_to_int32_round_to_zero( float128 ); 3128b75248bSross int64_t float128_to_int64( float128 ); 3138b75248bSross int64_t float128_to_int64_round_to_zero( float128 ); 3148b75248bSross float32 float128_to_float32( float128 ); 3158b75248bSross float64 float128_to_float64( float128 ); 3168b75248bSross #ifdef FLOATX80 3178b75248bSross floatx80 float128_to_floatx80( float128 ); 3188b75248bSross #endif 3198b75248bSross 3208b75248bSross /* 3218b75248bSross ------------------------------------------------------------------------------- 3228b75248bSross Software IEC/IEEE quadruple-precision operations. 3238b75248bSross ------------------------------------------------------------------------------- 3248b75248bSross */ 3258b75248bSross float128 float128_round_to_int( float128 ); 3268b75248bSross float128 float128_add( float128, float128 ); 3278b75248bSross float128 float128_sub( float128, float128 ); 3288b75248bSross float128 float128_mul( float128, float128 ); 3298b75248bSross float128 float128_div( float128, float128 ); 3308b75248bSross float128 float128_rem( float128, float128 ); 3318b75248bSross float128 float128_sqrt( float128 ); 3328b75248bSross int float128_eq( float128, float128 ); 3338b75248bSross int float128_le( float128, float128 ); 3348b75248bSross int float128_lt( float128, float128 ); 3358b75248bSross int float128_eq_signaling( float128, float128 ); 3368b75248bSross int float128_le_quiet( float128, float128 ); 3378b75248bSross int float128_lt_quiet( float128, float128 ); 3388b75248bSross int float128_is_signaling_nan( float128 ); 3398b75248bSross 3408b75248bSross #endif 3418b75248bSross 342