github.com/igggame/nebulas-go@v2.1.0+incompatible/nbre/3rd_party/SoftFloat-3e/source/include/softfloat.h (about) 1 2 /*============================================================================ 3 4 This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic 5 Package, Release 3e, by John R. Hauser. 6 7 Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the 8 University of California. All rights reserved. 9 10 Redistribution and use in source and binary forms, with or without 11 modification, are permitted provided that the following conditions are met: 12 13 1. Redistributions of source code must retain the above copyright notice, 14 this list of conditions, and the following disclaimer. 15 16 2. Redistributions in binary form must reproduce the above copyright notice, 17 this list of conditions, and the following disclaimer in the documentation 18 and/or other materials provided with the distribution. 19 20 3. Neither the name of the University nor the names of its contributors may 21 be used to endorse or promote products derived from this software without 22 specific prior written permission. 23 24 THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY 25 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 26 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE 27 DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY 28 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 29 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 31 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 32 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 35 =============================================================================*/ 36 37 38 /*============================================================================ 39 | Note: If SoftFloat is made available as a general library for programs to 40 | use, it is strongly recommended that a platform-specific version of this 41 | header, "softfloat.h", be created that folds in "softfloat_types.h" and that 42 | eliminates all dependencies on compile-time macros. 43 *============================================================================*/ 44 45 46 #ifndef softfloat_h 47 #define softfloat_h 1 48 49 #include <stdbool.h> 50 #include <stdint.h> 51 #ifdef __cplusplus 52 extern "C" { 53 #endif 54 55 #include "softfloat_types.h" 56 57 #ifndef THREAD_LOCAL 58 #define THREAD_LOCAL 59 #endif 60 61 /*---------------------------------------------------------------------------- 62 | Software floating-point underflow tininess-detection mode. 63 *----------------------------------------------------------------------------*/ 64 extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess; 65 enum { 66 softfloat_tininess_beforeRounding = 0, 67 softfloat_tininess_afterRounding = 1 68 }; 69 70 /*---------------------------------------------------------------------------- 71 | Software floating-point rounding mode. (Mode "odd" is supported only if 72 | SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.) 73 *----------------------------------------------------------------------------*/ 74 extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode; 75 enum { 76 softfloat_round_near_even = 0, 77 softfloat_round_minMag = 1, 78 softfloat_round_min = 2, 79 softfloat_round_max = 3, 80 softfloat_round_near_maxMag = 4, 81 softfloat_round_odd = 6 82 }; 83 84 /*---------------------------------------------------------------------------- 85 | Software floating-point exception flags. 86 *----------------------------------------------------------------------------*/ 87 extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags; 88 enum { 89 softfloat_flag_inexact = 1, 90 softfloat_flag_underflow = 2, 91 softfloat_flag_overflow = 4, 92 softfloat_flag_infinite = 8, 93 softfloat_flag_invalid = 16 94 }; 95 96 /*---------------------------------------------------------------------------- 97 | Routine to raise any or all of the software floating-point exception flags. 98 *----------------------------------------------------------------------------*/ 99 void softfloat_raiseFlags( uint_fast8_t ); 100 101 /*---------------------------------------------------------------------------- 102 | Integer-to-floating-point conversion routines. 103 *----------------------------------------------------------------------------*/ 104 float16_t ui32_to_f16( uint32_t ); 105 float32_t ui32_to_f32( uint32_t ); 106 float64_t ui32_to_f64( uint32_t ); 107 #ifdef SOFTFLOAT_FAST_INT64 108 extFloat80_t ui32_to_extF80( uint32_t ); 109 float128_t ui32_to_f128( uint32_t ); 110 #endif 111 void ui32_to_extF80M( uint32_t, extFloat80_t * ); 112 void ui32_to_f128M( uint32_t, float128_t * ); 113 float16_t ui64_to_f16( uint64_t ); 114 float32_t ui64_to_f32( uint64_t ); 115 float64_t ui64_to_f64( uint64_t ); 116 #ifdef SOFTFLOAT_FAST_INT64 117 extFloat80_t ui64_to_extF80( uint64_t ); 118 float128_t ui64_to_f128( uint64_t ); 119 #endif 120 void ui64_to_extF80M( uint64_t, extFloat80_t * ); 121 void ui64_to_f128M( uint64_t, float128_t * ); 122 float16_t i32_to_f16( int32_t ); 123 float32_t i32_to_f32( int32_t ); 124 float64_t i32_to_f64( int32_t ); 125 #ifdef SOFTFLOAT_FAST_INT64 126 extFloat80_t i32_to_extF80( int32_t ); 127 float128_t i32_to_f128( int32_t ); 128 #endif 129 void i32_to_extF80M( int32_t, extFloat80_t * ); 130 void i32_to_f128M( int32_t, float128_t * ); 131 float16_t i64_to_f16( int64_t ); 132 float32_t i64_to_f32( int64_t ); 133 float64_t i64_to_f64( int64_t ); 134 #ifdef SOFTFLOAT_FAST_INT64 135 extFloat80_t i64_to_extF80( int64_t ); 136 float128_t i64_to_f128( int64_t ); 137 #endif 138 void i64_to_extF80M( int64_t, extFloat80_t * ); 139 void i64_to_f128M( int64_t, float128_t * ); 140 141 /*---------------------------------------------------------------------------- 142 | 16-bit (half-precision) floating-point operations. 143 *----------------------------------------------------------------------------*/ 144 uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool ); 145 uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool ); 146 int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool ); 147 int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool ); 148 uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool ); 149 uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool ); 150 int_fast32_t f16_to_i32_r_minMag( float16_t, bool ); 151 int_fast64_t f16_to_i64_r_minMag( float16_t, bool ); 152 float32_t f16_to_f32( float16_t ); 153 float64_t f16_to_f64( float16_t ); 154 #ifdef SOFTFLOAT_FAST_INT64 155 extFloat80_t f16_to_extF80( float16_t ); 156 float128_t f16_to_f128( float16_t ); 157 #endif 158 void f16_to_extF80M( float16_t, extFloat80_t * ); 159 void f16_to_f128M( float16_t, float128_t * ); 160 float16_t f16_roundToInt( float16_t, uint_fast8_t, bool ); 161 float16_t f16_add( float16_t, float16_t ); 162 float16_t f16_sub( float16_t, float16_t ); 163 float16_t f16_mul( float16_t, float16_t ); 164 float16_t f16_mulAdd( float16_t, float16_t, float16_t ); 165 float16_t f16_div( float16_t, float16_t ); 166 float16_t f16_rem( float16_t, float16_t ); 167 float16_t f16_sqrt( float16_t ); 168 bool f16_eq( float16_t, float16_t ); 169 bool f16_le( float16_t, float16_t ); 170 bool f16_lt( float16_t, float16_t ); 171 bool f16_eq_signaling( float16_t, float16_t ); 172 bool f16_le_quiet( float16_t, float16_t ); 173 bool f16_lt_quiet( float16_t, float16_t ); 174 bool f16_isSignalingNaN( float16_t ); 175 176 /*---------------------------------------------------------------------------- 177 | 32-bit (single-precision) floating-point operations. 178 *----------------------------------------------------------------------------*/ 179 uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool ); 180 uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool ); 181 int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool ); 182 int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool ); 183 uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool ); 184 uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool ); 185 int_fast32_t f32_to_i32_r_minMag( float32_t, bool ); 186 int_fast64_t f32_to_i64_r_minMag( float32_t, bool ); 187 float16_t f32_to_f16( float32_t ); 188 float64_t f32_to_f64( float32_t ); 189 #ifdef SOFTFLOAT_FAST_INT64 190 extFloat80_t f32_to_extF80( float32_t ); 191 float128_t f32_to_f128( float32_t ); 192 #endif 193 void f32_to_extF80M( float32_t, extFloat80_t * ); 194 void f32_to_f128M( float32_t, float128_t * ); 195 float32_t f32_roundToInt( float32_t, uint_fast8_t, bool ); 196 float32_t f32_add( float32_t, float32_t ); 197 float32_t f32_sub( float32_t, float32_t ); 198 float32_t f32_mul( float32_t, float32_t ); 199 float32_t f32_mulAdd( float32_t, float32_t, float32_t ); 200 float32_t f32_div( float32_t, float32_t ); 201 float32_t f32_rem( float32_t, float32_t ); 202 float32_t f32_sqrt( float32_t ); 203 bool f32_eq( float32_t, float32_t ); 204 bool f32_le( float32_t, float32_t ); 205 bool f32_lt( float32_t, float32_t ); 206 bool f32_eq_signaling( float32_t, float32_t ); 207 bool f32_le_quiet( float32_t, float32_t ); 208 bool f32_lt_quiet( float32_t, float32_t ); 209 bool f32_isSignalingNaN( float32_t ); 210 211 /*---------------------------------------------------------------------------- 212 | 64-bit (double-precision) floating-point operations. 213 *----------------------------------------------------------------------------*/ 214 uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool ); 215 uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool ); 216 int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool ); 217 int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool ); 218 uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool ); 219 uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool ); 220 int_fast32_t f64_to_i32_r_minMag( float64_t, bool ); 221 int_fast64_t f64_to_i64_r_minMag( float64_t, bool ); 222 float16_t f64_to_f16( float64_t ); 223 float32_t f64_to_f32( float64_t ); 224 #ifdef SOFTFLOAT_FAST_INT64 225 extFloat80_t f64_to_extF80( float64_t ); 226 float128_t f64_to_f128( float64_t ); 227 #endif 228 void f64_to_extF80M( float64_t, extFloat80_t * ); 229 void f64_to_f128M( float64_t, float128_t * ); 230 float64_t f64_roundToInt( float64_t, uint_fast8_t, bool ); 231 float64_t f64_add( float64_t, float64_t ); 232 float64_t f64_sub( float64_t, float64_t ); 233 float64_t f64_mul( float64_t, float64_t ); 234 float64_t f64_mulAdd( float64_t, float64_t, float64_t ); 235 float64_t f64_div( float64_t, float64_t ); 236 float64_t f64_rem( float64_t, float64_t ); 237 float64_t f64_sqrt( float64_t ); 238 bool f64_eq( float64_t, float64_t ); 239 bool f64_le( float64_t, float64_t ); 240 bool f64_lt( float64_t, float64_t ); 241 bool f64_eq_signaling( float64_t, float64_t ); 242 bool f64_le_quiet( float64_t, float64_t ); 243 bool f64_lt_quiet( float64_t, float64_t ); 244 bool f64_isSignalingNaN( float64_t ); 245 246 /*---------------------------------------------------------------------------- 247 | Rounding precision for 80-bit extended double-precision floating-point. 248 | Valid values are 32, 64, and 80. 249 *----------------------------------------------------------------------------*/ 250 extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision; 251 252 /*---------------------------------------------------------------------------- 253 | 80-bit extended double-precision floating-point operations. 254 *----------------------------------------------------------------------------*/ 255 #ifdef SOFTFLOAT_FAST_INT64 256 uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool ); 257 uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool ); 258 int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool ); 259 int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool ); 260 uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool ); 261 uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool ); 262 int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool ); 263 int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool ); 264 float16_t extF80_to_f16( extFloat80_t ); 265 float32_t extF80_to_f32( extFloat80_t ); 266 float64_t extF80_to_f64( extFloat80_t ); 267 float128_t extF80_to_f128( extFloat80_t ); 268 extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool ); 269 extFloat80_t extF80_add( extFloat80_t, extFloat80_t ); 270 extFloat80_t extF80_sub( extFloat80_t, extFloat80_t ); 271 extFloat80_t extF80_mul( extFloat80_t, extFloat80_t ); 272 extFloat80_t extF80_div( extFloat80_t, extFloat80_t ); 273 extFloat80_t extF80_rem( extFloat80_t, extFloat80_t ); 274 extFloat80_t extF80_sqrt( extFloat80_t ); 275 bool extF80_eq( extFloat80_t, extFloat80_t ); 276 bool extF80_le( extFloat80_t, extFloat80_t ); 277 bool extF80_lt( extFloat80_t, extFloat80_t ); 278 bool extF80_eq_signaling( extFloat80_t, extFloat80_t ); 279 bool extF80_le_quiet( extFloat80_t, extFloat80_t ); 280 bool extF80_lt_quiet( extFloat80_t, extFloat80_t ); 281 bool extF80_isSignalingNaN( extFloat80_t ); 282 #endif 283 uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool ); 284 uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool ); 285 int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool ); 286 int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool ); 287 uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool ); 288 uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool ); 289 int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool ); 290 int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool ); 291 float16_t extF80M_to_f16( const extFloat80_t * ); 292 float32_t extF80M_to_f32( const extFloat80_t * ); 293 float64_t extF80M_to_f64( const extFloat80_t * ); 294 void extF80M_to_f128M( const extFloat80_t *, float128_t * ); 295 void 296 extF80M_roundToInt( 297 const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ); 298 void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); 299 void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); 300 void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); 301 void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); 302 void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); 303 void extF80M_sqrt( const extFloat80_t *, extFloat80_t * ); 304 bool extF80M_eq( const extFloat80_t *, const extFloat80_t * ); 305 bool extF80M_le( const extFloat80_t *, const extFloat80_t * ); 306 bool extF80M_lt( const extFloat80_t *, const extFloat80_t * ); 307 bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * ); 308 bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * ); 309 bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * ); 310 bool extF80M_isSignalingNaN( const extFloat80_t * ); 311 312 /*---------------------------------------------------------------------------- 313 | 128-bit (quadruple-precision) floating-point operations. 314 *----------------------------------------------------------------------------*/ 315 #ifdef SOFTFLOAT_FAST_INT64 316 uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool ); 317 uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool ); 318 int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool ); 319 int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool ); 320 uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool ); 321 uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool ); 322 int_fast32_t f128_to_i32_r_minMag( float128_t, bool ); 323 int_fast64_t f128_to_i64_r_minMag( float128_t, bool ); 324 float16_t f128_to_f16( float128_t ); 325 float32_t f128_to_f32( float128_t ); 326 float64_t f128_to_f64( float128_t ); 327 extFloat80_t f128_to_extF80( float128_t ); 328 float128_t f128_roundToInt( float128_t, uint_fast8_t, bool ); 329 float128_t f128_add( float128_t, float128_t ); 330 float128_t f128_sub( float128_t, float128_t ); 331 float128_t f128_mul( float128_t, float128_t ); 332 float128_t f128_mulAdd( float128_t, float128_t, float128_t ); 333 float128_t f128_div( float128_t, float128_t ); 334 float128_t f128_rem( float128_t, float128_t ); 335 float128_t f128_sqrt( float128_t ); 336 bool f128_eq( float128_t, float128_t ); 337 bool f128_le( float128_t, float128_t ); 338 bool f128_lt( float128_t, float128_t ); 339 bool f128_eq_signaling( float128_t, float128_t ); 340 bool f128_le_quiet( float128_t, float128_t ); 341 bool f128_lt_quiet( float128_t, float128_t ); 342 bool f128_isSignalingNaN( float128_t ); 343 #endif 344 uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool ); 345 uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool ); 346 int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool ); 347 int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool ); 348 uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool ); 349 uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool ); 350 int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool ); 351 int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool ); 352 float16_t f128M_to_f16( const float128_t * ); 353 float32_t f128M_to_f32( const float128_t * ); 354 float64_t f128M_to_f64( const float128_t * ); 355 void f128M_to_extF80M( const float128_t *, extFloat80_t * ); 356 void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * ); 357 void f128M_add( const float128_t *, const float128_t *, float128_t * ); 358 void f128M_sub( const float128_t *, const float128_t *, float128_t * ); 359 void f128M_mul( const float128_t *, const float128_t *, float128_t * ); 360 void 361 f128M_mulAdd( 362 const float128_t *, const float128_t *, const float128_t *, float128_t * 363 ); 364 void f128M_div( const float128_t *, const float128_t *, float128_t * ); 365 void f128M_rem( const float128_t *, const float128_t *, float128_t * ); 366 void f128M_sqrt( const float128_t *, float128_t * ); 367 bool f128M_eq( const float128_t *, const float128_t * ); 368 bool f128M_le( const float128_t *, const float128_t * ); 369 bool f128M_lt( const float128_t *, const float128_t * ); 370 bool f128M_eq_signaling( const float128_t *, const float128_t * ); 371 bool f128M_le_quiet( const float128_t *, const float128_t * ); 372 bool f128M_lt_quiet( const float128_t *, const float128_t * ); 373 bool f128M_isSignalingNaN( const float128_t * ); 374 375 #ifdef __cplusplus 376 } 377 #endif 378 #endif 379