Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | |
| 2 | /* |
| 3 | =============================================================================== |
| 4 | |
| 5 | This C header file is part of the SoftFloat IEC/IEEE Floating-point |
| 6 | Arithmetic Package, Release 2. |
| 7 | |
| 8 | Written by John R. Hauser. This work was made possible in part by the |
| 9 | International Computer Science Institute, located at Suite 600, 1947 Center |
| 10 | Street, Berkeley, California 94704. Funding was partially provided by the |
| 11 | National Science Foundation under grant MIP-9311980. The original version |
| 12 | of this code was written as part of a project to build a fixed-point vector |
| 13 | processor in collaboration with the University of California at Berkeley, |
| 14 | overseen by Profs. Nelson Morgan and John Wawrzynek. More information |
| 15 | is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ |
| 16 | arithmetic/softfloat.html'. |
| 17 | |
| 18 | THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort |
| 19 | has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT |
| 20 | TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO |
| 21 | PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY |
| 22 | AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. |
| 23 | |
| 24 | Derivative works are acceptable, even for commercial purposes, so long as |
| 25 | (1) they include prominent notice that the work is derivative, and (2) they |
| 26 | include prominent notice akin to these three paragraphs for those parts of |
| 27 | this code that are retained. |
| 28 | |
| 29 | =============================================================================== |
| 30 | */ |
| 31 | |
| 32 | #ifndef __SOFTFLOAT_H__ |
| 33 | #define __SOFTFLOAT_H__ |
| 34 | |
| 35 | #include <linux/config.h> |
| 36 | |
| 37 | /* |
| 38 | ------------------------------------------------------------------------------- |
| 39 | The macro `FLOATX80' must be defined to enable the extended double-precision |
| 40 | floating-point format `floatx80'. If this macro is not defined, the |
| 41 | `floatx80' type will not be defined, and none of the functions that either |
| 42 | input or output the `floatx80' type will be defined. |
| 43 | ------------------------------------------------------------------------------- |
| 44 | */ |
| 45 | #ifdef CONFIG_FPE_NWFPE_XP |
| 46 | #define FLOATX80 |
| 47 | #endif |
| 48 | |
| 49 | /* |
| 50 | ------------------------------------------------------------------------------- |
| 51 | Software IEC/IEEE floating-point types. |
| 52 | ------------------------------------------------------------------------------- |
| 53 | */ |
| 54 | typedef unsigned long int float32; |
| 55 | typedef unsigned long long float64; |
| 56 | typedef struct { |
| 57 | unsigned short high; |
| 58 | unsigned long long low; |
| 59 | } floatx80; |
| 60 | |
| 61 | /* |
| 62 | ------------------------------------------------------------------------------- |
| 63 | Software IEC/IEEE floating-point underflow tininess-detection mode. |
| 64 | ------------------------------------------------------------------------------- |
| 65 | */ |
| 66 | extern signed char float_detect_tininess; |
| 67 | enum { |
| 68 | float_tininess_after_rounding = 0, |
| 69 | float_tininess_before_rounding = 1 |
| 70 | }; |
| 71 | |
| 72 | /* |
| 73 | ------------------------------------------------------------------------------- |
| 74 | Software IEC/IEEE floating-point rounding mode. |
| 75 | ------------------------------------------------------------------------------- |
| 76 | */ |
| 77 | extern signed char float_rounding_mode; |
| 78 | enum { |
| 79 | float_round_nearest_even = 0, |
| 80 | float_round_to_zero = 1, |
| 81 | float_round_down = 2, |
| 82 | float_round_up = 3 |
| 83 | }; |
| 84 | |
| 85 | /* |
| 86 | ------------------------------------------------------------------------------- |
| 87 | Software IEC/IEEE floating-point exception flags. |
| 88 | ------------------------------------------------------------------------------- |
| 89 | extern signed char float_exception_flags; |
| 90 | enum { |
| 91 | float_flag_inexact = 1, |
| 92 | float_flag_underflow = 2, |
| 93 | float_flag_overflow = 4, |
| 94 | float_flag_divbyzero = 8, |
| 95 | float_flag_invalid = 16 |
| 96 | }; |
| 97 | |
| 98 | ScottB: November 4, 1998 |
| 99 | Changed the enumeration to match the bit order in the FPA11. |
| 100 | */ |
| 101 | |
| 102 | extern signed char float_exception_flags; |
| 103 | enum { |
| 104 | float_flag_invalid = 1, |
| 105 | float_flag_divbyzero = 2, |
| 106 | float_flag_overflow = 4, |
| 107 | float_flag_underflow = 8, |
| 108 | float_flag_inexact = 16 |
| 109 | }; |
| 110 | |
| 111 | /* |
| 112 | ------------------------------------------------------------------------------- |
| 113 | Routine to raise any or all of the software IEC/IEEE floating-point |
| 114 | exception flags. |
| 115 | ------------------------------------------------------------------------------- |
| 116 | */ |
| 117 | void float_raise( signed char ); |
| 118 | |
| 119 | /* |
| 120 | ------------------------------------------------------------------------------- |
| 121 | Software IEC/IEEE integer-to-floating-point conversion routines. |
| 122 | ------------------------------------------------------------------------------- |
| 123 | */ |
| 124 | float32 int32_to_float32( signed int ); |
| 125 | float64 int32_to_float64( signed int ); |
| 126 | #ifdef FLOATX80 |
| 127 | floatx80 int32_to_floatx80( signed int ); |
| 128 | #endif |
| 129 | |
| 130 | /* |
| 131 | ------------------------------------------------------------------------------- |
| 132 | Software IEC/IEEE single-precision conversion routines. |
| 133 | ------------------------------------------------------------------------------- |
| 134 | */ |
| 135 | signed int float32_to_int32( float32 ); |
| 136 | signed int float32_to_int32_round_to_zero( float32 ); |
| 137 | float64 float32_to_float64( float32 ); |
| 138 | #ifdef FLOATX80 |
| 139 | floatx80 float32_to_floatx80( float32 ); |
| 140 | #endif |
| 141 | |
| 142 | /* |
| 143 | ------------------------------------------------------------------------------- |
| 144 | Software IEC/IEEE single-precision operations. |
| 145 | ------------------------------------------------------------------------------- |
| 146 | */ |
| 147 | float32 float32_round_to_int( float32 ); |
| 148 | float32 float32_add( float32, float32 ); |
| 149 | float32 float32_sub( float32, float32 ); |
| 150 | float32 float32_mul( float32, float32 ); |
| 151 | float32 float32_div( float32, float32 ); |
| 152 | float32 float32_rem( float32, float32 ); |
| 153 | float32 float32_sqrt( float32 ); |
| 154 | char float32_eq( float32, float32 ); |
| 155 | char float32_le( float32, float32 ); |
| 156 | char float32_lt( float32, float32 ); |
| 157 | char float32_eq_signaling( float32, float32 ); |
| 158 | char float32_le_quiet( float32, float32 ); |
| 159 | char float32_lt_quiet( float32, float32 ); |
| 160 | char float32_is_signaling_nan( float32 ); |
| 161 | |
| 162 | /* |
| 163 | ------------------------------------------------------------------------------- |
| 164 | Software IEC/IEEE double-precision conversion routines. |
| 165 | ------------------------------------------------------------------------------- |
| 166 | */ |
| 167 | signed int float64_to_int32( float64 ); |
| 168 | signed int float64_to_int32_round_to_zero( float64 ); |
| 169 | float32 float64_to_float32( float64 ); |
| 170 | #ifdef FLOATX80 |
| 171 | floatx80 float64_to_floatx80( float64 ); |
| 172 | #endif |
| 173 | |
| 174 | /* |
| 175 | ------------------------------------------------------------------------------- |
| 176 | Software IEC/IEEE double-precision operations. |
| 177 | ------------------------------------------------------------------------------- |
| 178 | */ |
| 179 | float64 float64_round_to_int( float64 ); |
| 180 | float64 float64_add( float64, float64 ); |
| 181 | float64 float64_sub( float64, float64 ); |
| 182 | float64 float64_mul( float64, float64 ); |
| 183 | float64 float64_div( float64, float64 ); |
| 184 | float64 float64_rem( float64, float64 ); |
| 185 | float64 float64_sqrt( float64 ); |
| 186 | char float64_eq( float64, float64 ); |
| 187 | char float64_le( float64, float64 ); |
| 188 | char float64_lt( float64, float64 ); |
| 189 | char float64_eq_signaling( float64, float64 ); |
| 190 | char float64_le_quiet( float64, float64 ); |
| 191 | char float64_lt_quiet( float64, float64 ); |
| 192 | char float64_is_signaling_nan( float64 ); |
| 193 | |
| 194 | #ifdef FLOATX80 |
| 195 | |
| 196 | /* |
| 197 | ------------------------------------------------------------------------------- |
| 198 | Software IEC/IEEE extended double-precision conversion routines. |
| 199 | ------------------------------------------------------------------------------- |
| 200 | */ |
| 201 | signed int floatx80_to_int32( floatx80 ); |
| 202 | signed int floatx80_to_int32_round_to_zero( floatx80 ); |
| 203 | float32 floatx80_to_float32( floatx80 ); |
| 204 | float64 floatx80_to_float64( floatx80 ); |
| 205 | |
| 206 | /* |
| 207 | ------------------------------------------------------------------------------- |
| 208 | Software IEC/IEEE extended double-precision rounding precision. Valid |
| 209 | values are 32, 64, and 80. |
| 210 | ------------------------------------------------------------------------------- |
| 211 | */ |
| 212 | extern signed char floatx80_rounding_precision; |
| 213 | |
| 214 | /* |
| 215 | ------------------------------------------------------------------------------- |
| 216 | Software IEC/IEEE extended double-precision operations. |
| 217 | ------------------------------------------------------------------------------- |
| 218 | */ |
| 219 | floatx80 floatx80_round_to_int( floatx80 ); |
| 220 | floatx80 floatx80_add( floatx80, floatx80 ); |
| 221 | floatx80 floatx80_sub( floatx80, floatx80 ); |
| 222 | floatx80 floatx80_mul( floatx80, floatx80 ); |
| 223 | floatx80 floatx80_div( floatx80, floatx80 ); |
| 224 | floatx80 floatx80_rem( floatx80, floatx80 ); |
| 225 | floatx80 floatx80_sqrt( floatx80 ); |
| 226 | char floatx80_eq( floatx80, floatx80 ); |
| 227 | char floatx80_le( floatx80, floatx80 ); |
| 228 | char floatx80_lt( floatx80, floatx80 ); |
| 229 | char floatx80_eq_signaling( floatx80, floatx80 ); |
| 230 | char floatx80_le_quiet( floatx80, floatx80 ); |
| 231 | char floatx80_lt_quiet( floatx80, floatx80 ); |
| 232 | char floatx80_is_signaling_nan( floatx80 ); |
| 233 | |
| 234 | #endif |
| 235 | |
| 236 | static inline flag extractFloat32Sign(float32 a) |
| 237 | { |
| 238 | return a >> 31; |
| 239 | } |
| 240 | |
| 241 | static inline flag float32_eq_nocheck(float32 a, float32 b) |
| 242 | { |
| 243 | return (a == b) || ((bits32) ((a | b) << 1) == 0); |
| 244 | } |
| 245 | |
| 246 | static inline flag float32_lt_nocheck(float32 a, float32 b) |
| 247 | { |
| 248 | flag aSign, bSign; |
| 249 | |
| 250 | aSign = extractFloat32Sign(a); |
| 251 | bSign = extractFloat32Sign(b); |
| 252 | if (aSign != bSign) |
| 253 | return aSign && ((bits32) ((a | b) << 1) != 0); |
| 254 | return (a != b) && (aSign ^ (a < b)); |
| 255 | } |
| 256 | |
| 257 | static inline flag extractFloat64Sign(float64 a) |
| 258 | { |
| 259 | return a >> 63; |
| 260 | } |
| 261 | |
| 262 | static inline flag float64_eq_nocheck(float64 a, float64 b) |
| 263 | { |
| 264 | return (a == b) || ((bits64) ((a | b) << 1) == 0); |
| 265 | } |
| 266 | |
| 267 | static inline flag float64_lt_nocheck(float64 a, float64 b) |
| 268 | { |
| 269 | flag aSign, bSign; |
| 270 | |
| 271 | aSign = extractFloat64Sign(a); |
| 272 | bSign = extractFloat64Sign(b); |
| 273 | if (aSign != bSign) |
| 274 | return aSign && ((bits64) ((a | b) << 1) != 0); |
| 275 | return (a != b) && (aSign ^ (a < b)); |
| 276 | } |
| 277 | |
| 278 | #endif |