softfloat/softfloat.h

   1
   2 /*============================================================================
   3
   4 This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
   5 Package, Release 3d, 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 #include "softfloat_types.h"
  52
  53 #ifndef THREAD_LOCAL
  54 #define THREAD_LOCAL
  55 #endif
  56
  57 #ifdef __cplusplus
  58 extern "C" {
  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         = 5
  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 uint_fast16_t f32_classify( float32_t );
 211
 212 /*----------------------------------------------------------------------------
 213 | 64-bit (double-precision) floating-point operations.
 214 *----------------------------------------------------------------------------*/
 215 uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
 216 uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
 217 int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
 218 int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );
 219 uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );
 220 uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );
 221 int_fast32_t f64_to_i32_r_minMag( float64_t, bool );
 222 int_fast64_t f64_to_i64_r_minMag( float64_t, bool );
 223 float16_t f64_to_f16( float64_t );
 224 float32_t f64_to_f32( float64_t );
 225 #ifdef SOFTFLOAT_FAST_INT64
 226 extFloat80_t f64_to_extF80( float64_t );
 227 float128_t f64_to_f128( float64_t );
 228 #endif
 229 void f64_to_extF80M( float64_t, extFloat80_t * );
 230 void f64_to_f128M( float64_t, float128_t * );
 231 float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );
 232 float64_t f64_add( float64_t, float64_t );
 233 float64_t f64_sub( float64_t, float64_t );
 234 float64_t f64_mul( float64_t, float64_t );
 235 float64_t f64_mulAdd( float64_t, float64_t, float64_t );
 236 float64_t f64_div( float64_t, float64_t );
 237 float64_t f64_rem( float64_t, float64_t );
 238 float64_t f64_sqrt( float64_t );
 239 bool f64_eq( float64_t, float64_t );
 240 bool f64_le( float64_t, float64_t );
 241 bool f64_lt( float64_t, float64_t );
 242 bool f64_eq_signaling( float64_t, float64_t );
 243 bool f64_le_quiet( float64_t, float64_t );
 244 bool f64_lt_quiet( float64_t, float64_t );
 245 bool f64_isSignalingNaN( float64_t );
 246 uint_fast16_t f64_classify( float64_t );
 247
 248 /*----------------------------------------------------------------------------
 249 | Rounding precision for 80-bit extended double-precision floating-point.
 250 | Valid values are 32, 64, and 80.
 251 *----------------------------------------------------------------------------*/
 252 extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
 253
 254 /*----------------------------------------------------------------------------
 255 | 80-bit extended double-precision floating-point operations.
 256 *----------------------------------------------------------------------------*/
 257 #ifdef SOFTFLOAT_FAST_INT64
 258 uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
 259 uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
 260 int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
 261 int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
 262 uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
 263 uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
 264 int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
 265 int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
 266 float16_t extF80_to_f16( extFloat80_t );
 267 float32_t extF80_to_f32( extFloat80_t );
 268 float64_t extF80_to_f64( extFloat80_t );
 269 float128_t extF80_to_f128( extFloat80_t );
 270 extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
 271 extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
 272 extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
 273 extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
 274 extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
 275 extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
 276 extFloat80_t extF80_sqrt( extFloat80_t );
 277 bool extF80_eq( extFloat80_t, extFloat80_t );
 278 bool extF80_le( extFloat80_t, extFloat80_t );
 279 bool extF80_lt( extFloat80_t, extFloat80_t );
 280 bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
 281 bool extF80_le_quiet( extFloat80_t, extFloat80_t );
 282 bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
 283 bool extF80_isSignalingNaN( extFloat80_t );
 284 #endif
 285 uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
 286 uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
 287 int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
 288 int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
 289 uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
 290 uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
 291 int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
 292 int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
 293 float16_t extF80M_to_f16( const extFloat80_t * );
 294 float32_t extF80M_to_f32( const extFloat80_t * );
 295 float64_t extF80M_to_f64( const extFloat80_t * );
 296 void extF80M_to_f128M( const extFloat80_t *, float128_t * );
 297 void
 298  extF80M_roundToInt(
 299      const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
 300 void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
 301 void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
 302 void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
 303 void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
 304 void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
 305 void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
 306 bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
 307 bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
 308 bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
 309 bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
 310 bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
 311 bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
 312 bool extF80M_isSignalingNaN( const extFloat80_t * );
 313
 314 /*----------------------------------------------------------------------------
 315 | 128-bit (quadruple-precision) floating-point operations.
 316 *----------------------------------------------------------------------------*/
 317 #ifdef SOFTFLOAT_FAST_INT64
 318 uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
 319 uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
 320 int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
 321 int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );
 322 uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );
 323 uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );
 324 int_fast32_t f128_to_i32_r_minMag( float128_t, bool );
 325 int_fast64_t f128_to_i64_r_minMag( float128_t, bool );
 326 float16_t f128_to_f16( float128_t );
 327 float32_t f128_to_f32( float128_t );
 328 float64_t f128_to_f64( float128_t );
 329 extFloat80_t f128_to_extF80( float128_t );
 330 float128_t f128_roundToInt( float128_t, uint_fast8_t, bool );
 331 float128_t f128_add( float128_t, float128_t );
 332 float128_t f128_sub( float128_t, float128_t );
 333 float128_t f128_mul( float128_t, float128_t );
 334 float128_t f128_mulAdd( float128_t, float128_t, float128_t );
 335 float128_t f128_div( float128_t, float128_t );
 336 float128_t f128_rem( float128_t, float128_t );
 337 float128_t f128_sqrt( float128_t );
 338 bool f128_eq( float128_t, float128_t );
 339 bool f128_le( float128_t, float128_t );
 340 bool f128_lt( float128_t, float128_t );
 341 bool f128_eq_signaling( float128_t, float128_t );
 342 bool f128_le_quiet( float128_t, float128_t );
 343 bool f128_lt_quiet( float128_t, float128_t );
 344 bool f128_isSignalingNaN( float128_t );
 345 uint_fast16_t f128_classify( float128_t );
 346 #endif
 347 uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
 348 uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
 349 int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
 350 int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
 351 uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
 352 uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
 353 int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
 354 int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
 355 float16_t f128M_to_f16( const float128_t * );
 356 float32_t f128M_to_f32( const float128_t * );
 357 float64_t f128M_to_f64( const float128_t * );
 358 void f128M_to_extF80M( const float128_t *, extFloat80_t * );
 359 void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
 360 void f128M_add( const float128_t *, const float128_t *, float128_t * );
 361 void f128M_sub( const float128_t *, const float128_t *, float128_t * );
 362 void f128M_mul( const float128_t *, const float128_t *, float128_t * );
 363 void
 364  f128M_mulAdd(
 365      const float128_t *, const float128_t *, const float128_t *, float128_t *
 366  );
 367 void f128M_div( const float128_t *, const float128_t *, float128_t * );
 368 void f128M_rem( const float128_t *, const float128_t *, float128_t * );
 369 void f128M_sqrt( const float128_t *, float128_t * );
 370 bool f128M_eq( const float128_t *, const float128_t * );
 371 bool f128M_le( const float128_t *, const float128_t * );
 372 bool f128M_lt( const float128_t *, const float128_t * );
 373 bool f128M_eq_signaling( const float128_t *, const float128_t * );
 374 bool f128M_le_quiet( const float128_t *, const float128_t * );
 375 bool f128M_lt_quiet( const float128_t *, const float128_t * );
 376 bool f128M_isSignalingNaN( const float128_t * );
 377
 378 #ifdef __cplusplus
 379 }
 380 #endif
 381
 382 #endif
 383