Changes in uspace/lib/softfloat/generic/add.c [c67aff2:750636a] in mainline
- File:
-
- 1 edited
-
uspace/lib/softfloat/generic/add.c (modified) (18 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/softfloat/generic/add.c
rc67aff2 r750636a 1 1 /* 2 2 * Copyright (c) 2005 Josef Cejka 3 * Copyright (c) 2011 Petr Koupy4 3 * All rights reserved. 5 4 * … … 31 30 * @{ 32 31 */ 33 /** @file Addition functions.32 /** @file 34 33 */ 35 34 … … 37 36 #include <add.h> 38 37 #include <comparison.h> 39 #include <common.h> 40 41 /** 42 * Add two single-precision floats with the same signs. 43 * 44 * @param a First input operand. 45 * @param b Second input operand. 46 * @return Result of addition. 38 39 /** Add two Float32 numbers with same signs 47 40 */ 48 41 float32 addFloat32(float32 a, float32 b) 49 42 { 50 43 int expdiff; 51 uint32_t exp1, exp2, 44 uint32_t exp1, exp2,frac1, frac2; 52 45 53 46 expdiff = a.parts.exp - b.parts.exp; … … 56 49 /* TODO: fix SigNaN */ 57 50 if (isFloat32SigNaN(b)) { 58 } 59 60 return b; 61 } 51 }; 52 53 return b; 54 }; 62 55 63 56 if (b.parts.exp == FLOAT32_MAX_EXPONENT) { … … 74 67 /* TODO: fix SigNaN */ 75 68 if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) { 76 } 77 return (isFloat32NaN(a) ? a :b);78 } 69 }; 70 return (isFloat32NaN(a)?a:b); 71 }; 79 72 80 73 if (a.parts.exp == FLOAT32_MAX_EXPONENT) { … … 86 79 frac2 = b.parts.fraction; 87 80 exp2 = b.parts.exp; 88 } 81 }; 89 82 90 83 if (exp1 == 0) { … … 94 87 /* result is not denormalized */ 95 88 a.parts.exp = 1; 96 } 89 }; 97 90 a.parts.fraction = frac1; 98 91 return a; 99 } 92 }; 100 93 101 94 frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */ … … 107 100 /* add hidden bit to second operand */ 108 101 frac2 |= FLOAT32_HIDDEN_BIT_MASK; 109 } 102 }; 110 103 111 104 /* create some space for rounding */ … … 125 118 ++exp1; 126 119 frac1 >>= 1; 127 } 120 }; 128 121 129 122 /* rounding - if first bit after fraction is set then round up */ … … 134 127 ++exp1; 135 128 frac1 >>= 1; 136 } 129 }; 130 137 131 138 132 if ((exp1 == FLOAT32_MAX_EXPONENT ) || (exp2 > exp1)) { 139 /* overflow - set infinity as result */140 a.parts.exp = FLOAT32_MAX_EXPONENT;141 a.parts.fraction = 0;142 return a;143 }133 /* overflow - set infinity as result */ 134 a.parts.exp = FLOAT32_MAX_EXPONENT; 135 a.parts.fraction = 0; 136 return a; 137 } 144 138 145 139 a.parts.exp = exp1; 146 140 147 141 /* Clear hidden bit and shift */ 148 a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ;142 a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ; 149 143 return a; 150 144 } 151 145 152 /** 153 * Add two double-precision floats with the same signs. 154 * 155 * @param a First input operand. 156 * @param b Second input operand. 157 * @return Result of addition. 146 /** Add two Float64 numbers with same signs 158 147 */ 159 148 float64 addFloat64(float64 a, float64 b) … … 163 152 uint64_t frac1, frac2; 164 153 165 expdiff = ((int )a.parts.exp) - b.parts.exp;154 expdiff = ((int )a.parts.exp) - b.parts.exp; 166 155 if (expdiff < 0) { 167 156 if (isFloat64NaN(b)) { 168 157 /* TODO: fix SigNaN */ 169 158 if (isFloat64SigNaN(b)) { 170 } 171 172 return b; 173 } 159 }; 160 161 return b; 162 }; 174 163 175 164 /* b is infinity and a not */ 176 if (b.parts.exp == FLOAT64_MAX_EXPONENT ) {165 if (b.parts.exp == FLOAT64_MAX_EXPONENT ) { 177 166 return b; 178 167 } … … 187 176 /* TODO: fix SigNaN */ 188 177 if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) { 189 } 190 return a; 191 } 178 }; 179 return a; 180 }; 192 181 193 182 /* a is infinity and b not */ 194 if (a.parts.exp == FLOAT64_MAX_EXPONENT ) {183 if (a.parts.exp == FLOAT64_MAX_EXPONENT ) { 195 184 return a; 196 185 } … … 200 189 frac2 = b.parts.fraction; 201 190 exp2 = b.parts.exp; 202 } 191 }; 203 192 204 193 if (exp1 == 0) { … … 208 197 /* result is not denormalized */ 209 198 a.parts.exp = 1; 210 } 199 }; 211 200 a.parts.fraction = frac1; 212 201 return a; 213 } 202 }; 214 203 215 204 /* add hidden bit - frac1 is sure not denormalized */ … … 223 212 /* is not denormalized */ 224 213 frac2 |= FLOAT64_HIDDEN_BIT_MASK; 225 } 214 }; 226 215 227 216 /* create some space for rounding */ … … 229 218 frac2 <<= 6; 230 219 231 if (expdiff < (FLOAT64_FRACTION_SIZE + 2) ) {220 if (expdiff < (FLOAT64_FRACTION_SIZE + 2) ) { 232 221 frac2 >>= expdiff; 233 222 frac1 += frac2; … … 238 227 } 239 228 240 if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) {241 ++exp1; 242 frac1 >>= 1; 243 } 229 if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) { 230 ++exp1; 231 frac1 >>= 1; 232 }; 244 233 245 234 /* rounding - if first bit after fraction is set then round up */ … … 250 239 ++exp1; 251 240 frac1 >>= 1; 252 } 241 }; 253 242 254 243 if ((exp1 == FLOAT64_MAX_EXPONENT ) || (exp2 > exp1)) { 255 /* overflow - set infinity as result */256 a.parts.exp = FLOAT64_MAX_EXPONENT;257 a.parts.fraction = 0;258 return a;259 }244 /* overflow - set infinity as result */ 245 a.parts.exp = FLOAT64_MAX_EXPONENT; 246 a.parts.fraction = 0; 247 return a; 248 } 260 249 261 250 a.parts.exp = exp1; 262 251 /* Clear hidden bit and shift */ 263 a.parts.fraction = ((frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK)); 252 a.parts.fraction = ( (frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK)); 253 264 254 return a; 265 255 } 266 256 267 /**268 * Add two quadruple-precision floats with the same signs.269 *270 * @param a First input operand.271 * @param b Second input operand.272 * @return Result of addition.273 */274 float128 addFloat128(float128 a, float128 b)275 {276 int expdiff;277 uint32_t exp1, exp2;278 uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;279 280 expdiff = ((int) a.parts.exp) - b.parts.exp;281 if (expdiff < 0) {282 if (isFloat128NaN(b)) {283 /* TODO: fix SigNaN */284 if (isFloat128SigNaN(b)) {285 }286 287 return b;288 }289 290 /* b is infinity and a not */291 if (b.parts.exp == FLOAT128_MAX_EXPONENT) {292 return b;293 }294 295 frac1_hi = b.parts.frac_hi;296 frac1_lo = b.parts.frac_lo;297 exp1 = b.parts.exp;298 frac2_hi = a.parts.frac_hi;299 frac2_lo = a.parts.frac_lo;300 exp2 = a.parts.exp;301 expdiff *= -1;302 } else {303 if (isFloat128NaN(a)) {304 /* TODO: fix SigNaN */305 if (isFloat128SigNaN(a) || isFloat128SigNaN(b)) {306 }307 return a;308 }309 310 /* a is infinity and b not */311 if (a.parts.exp == FLOAT128_MAX_EXPONENT) {312 return a;313 }314 315 frac1_hi = a.parts.frac_hi;316 frac1_lo = a.parts.frac_lo;317 exp1 = a.parts.exp;318 frac2_hi = b.parts.frac_hi;319 frac2_lo = b.parts.frac_lo;320 exp2 = b.parts.exp;321 }322 323 if (exp1 == 0) {324 /* both are denormalized */325 add128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &frac1_hi, &frac1_lo);326 327 and128(frac1_hi, frac1_lo,328 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,329 &tmp_hi, &tmp_lo);330 if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) {331 /* result is not denormalized */332 a.parts.exp = 1;333 }334 335 a.parts.frac_hi = frac1_hi;336 a.parts.frac_lo = frac1_lo;337 return a;338 }339 340 /* add hidden bit - frac1 is sure not denormalized */341 or128(frac1_hi, frac1_lo,342 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,343 &frac1_hi, &frac1_lo);344 345 /* second operand ... */346 if (exp2 == 0) {347 /* ... is denormalized */348 --expdiff;349 } else {350 /* is not denormalized */351 or128(frac2_hi, frac2_lo,352 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,353 &frac2_hi, &frac2_lo);354 }355 356 /* create some space for rounding */357 lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);358 lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo);359 360 if (expdiff < (FLOAT128_FRACTION_SIZE + 2)) {361 rshift128(frac2_hi, frac2_lo, expdiff, &frac2_hi, &frac2_lo);362 add128(frac1_hi, frac1_lo, frac2_hi, frac2_lo, &frac1_hi, &frac1_lo);363 } else {364 a.parts.exp = exp1;365 366 rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);367 not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,368 &tmp_hi, &tmp_lo);369 and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);370 371 a.parts.frac_hi = tmp_hi;372 a.parts.frac_lo = tmp_lo;373 return a;374 }375 376 lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7,377 &tmp_hi, &tmp_lo);378 and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);379 if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) {380 ++exp1;381 rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);382 }383 384 /* rounding - if first bit after fraction is set then round up */385 add128(frac1_hi, frac1_lo, 0x0ll, 0x1ll << 5, &frac1_hi, &frac1_lo);386 387 lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7,388 &tmp_hi, &tmp_lo);389 and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);390 if (lt128(0x0ll, 0x0ll, tmp_hi, tmp_lo)) {391 /* rounding overflow */392 ++exp1;393 rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);394 }395 396 if ((exp1 == FLOAT128_MAX_EXPONENT ) || (exp2 > exp1)) {397 /* overflow - set infinity as result */398 a.parts.exp = FLOAT64_MAX_EXPONENT;399 a.parts.frac_hi = 0;400 a.parts.frac_lo = 0;401 return a;402 }403 404 a.parts.exp = exp1;405 406 /* Clear hidden bit and shift */407 rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);408 not128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,409 &tmp_hi, &tmp_lo);410 and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);411 412 a.parts.frac_hi = tmp_hi;413 a.parts.frac_lo = tmp_lo;414 415 return a;416 }417 418 257 /** @} 419 258 */
Note:
See TracChangeset
for help on using the changeset viewer.
