github.com/igggame/nebulas-go@v2.1.0+incompatible/nbre/3rd_party/SoftFloat-3e/source/include/internals.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 #ifndef internals_h 38 #define internals_h 1 39 40 #include <stdbool.h> 41 #include <stdint.h> 42 #include "primitives.h" 43 #include "softfloat_types.h" 44 45 union ui16_f16 { uint16_t ui; float16_t f; }; 46 union ui32_f32 { uint32_t ui; float32_t f; }; 47 union ui64_f64 { uint64_t ui; float64_t f; }; 48 49 #ifdef SOFTFLOAT_FAST_INT64 50 union extF80M_extF80 { struct extFloat80M fM; extFloat80_t f; }; 51 union ui128_f128 { struct uint128 ui; float128_t f; }; 52 #endif 53 54 enum { 55 softfloat_mulAdd_subC = 1, 56 softfloat_mulAdd_subProd = 2 57 }; 58 59 /*---------------------------------------------------------------------------- 60 *----------------------------------------------------------------------------*/ 61 uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool ); 62 63 #ifdef SOFTFLOAT_FAST_INT64 64 uint_fast64_t 65 softfloat_roundToUI64( 66 bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool ); 67 #else 68 uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool ); 69 #endif 70 71 int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool ); 72 73 #ifdef SOFTFLOAT_FAST_INT64 74 int_fast64_t 75 softfloat_roundToI64( 76 bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool ); 77 #else 78 int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool ); 79 #endif 80 81 /*---------------------------------------------------------------------------- 82 *----------------------------------------------------------------------------*/ 83 #define signF16UI( a ) ((bool) ((uint16_t) (a)>>15)) 84 #define expF16UI( a ) ((int_fast8_t) ((a)>>10) & 0x1F) 85 #define fracF16UI( a ) ((a) & 0x03FF) 86 #define packToF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<10) + (sig)) 87 88 #define isNaNF16UI( a ) (((~(a) & 0x7C00) == 0) && ((a) & 0x03FF)) 89 90 struct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; }; 91 struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t ); 92 93 float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t ); 94 float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t ); 95 96 float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t ); 97 float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t ); 98 float16_t 99 softfloat_mulAddF16( 100 uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t ); 101 102 /*---------------------------------------------------------------------------- 103 *----------------------------------------------------------------------------*/ 104 #define signF32UI( a ) ((bool) ((uint32_t) (a)>>31)) 105 #define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF) 106 #define fracF32UI( a ) ((a) & 0x007FFFFF) 107 #define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig)) 108 109 #define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF)) 110 111 struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; }; 112 struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t ); 113 114 float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t ); 115 float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t ); 116 117 float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t ); 118 float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t ); 119 float32_t 120 softfloat_mulAddF32( 121 uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t ); 122 123 /*---------------------------------------------------------------------------- 124 *----------------------------------------------------------------------------*/ 125 #define signF64UI( a ) ((bool) ((uint64_t) (a)>>63)) 126 #define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF) 127 #define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )) 128 #define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig))) 129 130 #define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))) 131 132 struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; }; 133 struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t ); 134 135 float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t ); 136 float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t ); 137 138 float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool ); 139 float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool ); 140 float64_t 141 softfloat_mulAddF64( 142 uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t ); 143 144 /*---------------------------------------------------------------------------- 145 *----------------------------------------------------------------------------*/ 146 #define signExtF80UI64( a64 ) ((bool) ((uint16_t) (a64)>>15)) 147 #define expExtF80UI64( a64 ) ((a64) & 0x7FFF) 148 #define packToExtF80UI64( sign, exp ) ((uint_fast16_t) (sign)<<15 | (exp)) 149 150 #define isNaNExtF80UI( a64, a0 ) ((((a64) & 0x7FFF) == 0x7FFF) && ((a0) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))) 151 152 #ifdef SOFTFLOAT_FAST_INT64 153 154 /*---------------------------------------------------------------------------- 155 *----------------------------------------------------------------------------*/ 156 157 struct exp32_sig64 { int_fast32_t exp; uint64_t sig; }; 158 struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t ); 159 160 extFloat80_t 161 softfloat_roundPackToExtF80( 162 bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t ); 163 extFloat80_t 164 softfloat_normRoundPackToExtF80( 165 bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t ); 166 167 extFloat80_t 168 softfloat_addMagsExtF80( 169 uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); 170 extFloat80_t 171 softfloat_subMagsExtF80( 172 uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); 173 174 /*---------------------------------------------------------------------------- 175 *----------------------------------------------------------------------------*/ 176 #define signF128UI64( a64 ) ((bool) ((uint64_t) (a64)>>63)) 177 #define expF128UI64( a64 ) ((int_fast32_t) ((a64)>>48) & 0x7FFF) 178 #define fracF128UI64( a64 ) ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF )) 179 #define packToF128UI64( sign, exp, sig64 ) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<48) + (sig64)) 180 181 #define isNaNF128UI( a64, a0 ) (((~(a64) & UINT64_C( 0x7FFF000000000000 )) == 0) && (a0 || ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF )))) 182 183 struct exp32_sig128 { int_fast32_t exp; struct uint128 sig; }; 184 struct exp32_sig128 185 softfloat_normSubnormalF128Sig( uint_fast64_t, uint_fast64_t ); 186 187 float128_t 188 softfloat_roundPackToF128( 189 bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t ); 190 float128_t 191 softfloat_normRoundPackToF128( 192 bool, int_fast32_t, uint_fast64_t, uint_fast64_t ); 193 194 float128_t 195 softfloat_addMagsF128( 196 uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); 197 float128_t 198 softfloat_subMagsF128( 199 uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); 200 float128_t 201 softfloat_mulAddF128( 202 uint_fast64_t, 203 uint_fast64_t, 204 uint_fast64_t, 205 uint_fast64_t, 206 uint_fast64_t, 207 uint_fast64_t, 208 uint_fast8_t 209 ); 210 211 #else 212 213 /*---------------------------------------------------------------------------- 214 *----------------------------------------------------------------------------*/ 215 216 bool 217 softfloat_tryPropagateNaNExtF80M( 218 const struct extFloat80M *, 219 const struct extFloat80M *, 220 struct extFloat80M * 221 ); 222 void softfloat_invalidExtF80M( struct extFloat80M * ); 223 224 int softfloat_normExtF80SigM( uint64_t * ); 225 226 void 227 softfloat_roundPackMToExtF80M( 228 bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * ); 229 void 230 softfloat_normRoundPackMToExtF80M( 231 bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * ); 232 233 void 234 softfloat_addExtF80M( 235 const struct extFloat80M *, 236 const struct extFloat80M *, 237 struct extFloat80M *, 238 bool 239 ); 240 241 int 242 softfloat_compareNonnormExtF80M( 243 const struct extFloat80M *, const struct extFloat80M * ); 244 245 /*---------------------------------------------------------------------------- 246 *----------------------------------------------------------------------------*/ 247 #define signF128UI96( a96 ) ((bool) ((uint32_t) (a96)>>31)) 248 #define expF128UI96( a96 ) ((int32_t) ((a96)>>16) & 0x7FFF) 249 #define fracF128UI96( a96 ) ((a96) & 0x0000FFFF) 250 #define packToF128UI96( sign, exp, sig96 ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<16) + (sig96)) 251 252 bool softfloat_isNaNF128M( const uint32_t * ); 253 254 bool 255 softfloat_tryPropagateNaNF128M( 256 const uint32_t *, const uint32_t *, uint32_t * ); 257 void softfloat_invalidF128M( uint32_t * ); 258 259 int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * ); 260 261 void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * ); 262 void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * ); 263 264 void 265 softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool ); 266 void 267 softfloat_mulAddF128M( 268 const uint32_t *, 269 const uint32_t *, 270 const uint32_t *, 271 uint32_t *, 272 uint_fast8_t 273 ); 274 275 #endif 276 277 #endif 278