Revision bb98fe42 fpu/softfloat-macros.h
| b/fpu/softfloat-macros.h | ||
|---|---|---|
| 44 | 44 |
| The result is stored in the location pointed to by `zPtr'. |
| 45 | 45 |
*----------------------------------------------------------------------------*/ |
| 46 | 46 |
|
| 47 |
INLINE void shift32RightJamming( bits32 a, int16 count, bits32 *zPtr )
|
|
| 47 |
INLINE void shift32RightJamming( uint32_t a, int16 count, uint32_t *zPtr )
|
|
| 48 | 48 |
{
|
| 49 |
bits32 z;
|
|
| 49 |
uint32_t z;
|
|
| 50 | 50 |
|
| 51 | 51 |
if ( count == 0 ) {
|
| 52 | 52 |
z = a; |
| ... | ... | |
| 70 | 70 |
| The result is stored in the location pointed to by `zPtr'. |
| 71 | 71 |
*----------------------------------------------------------------------------*/ |
| 72 | 72 |
|
| 73 |
INLINE void shift64RightJamming( bits64 a, int16 count, bits64 *zPtr )
|
|
| 73 |
INLINE void shift64RightJamming( uint64_t a, int16 count, uint64_t *zPtr )
|
|
| 74 | 74 |
{
|
| 75 |
bits64 z;
|
|
| 75 |
uint64_t z;
|
|
| 76 | 76 |
|
| 77 | 77 |
if ( count == 0 ) {
|
| 78 | 78 |
z = a; |
| ... | ... | |
| 106 | 106 |
|
| 107 | 107 |
INLINE void |
| 108 | 108 |
shift64ExtraRightJamming( |
| 109 |
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 109 |
uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 110 | 110 |
{
|
| 111 |
bits64 z0, z1;
|
|
| 111 |
uint64_t z0, z1;
|
|
| 112 | 112 |
int8 negCount = ( - count ) & 63; |
| 113 | 113 |
|
| 114 | 114 |
if ( count == 0 ) {
|
| ... | ... | |
| 143 | 143 |
|
| 144 | 144 |
INLINE void |
| 145 | 145 |
shift128Right( |
| 146 |
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 146 |
uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 147 | 147 |
{
|
| 148 |
bits64 z0, z1;
|
|
| 148 |
uint64_t z0, z1;
|
|
| 149 | 149 |
int8 negCount = ( - count ) & 63; |
| 150 | 150 |
|
| 151 | 151 |
if ( count == 0 ) {
|
| ... | ... | |
| 178 | 178 |
|
| 179 | 179 |
INLINE void |
| 180 | 180 |
shift128RightJamming( |
| 181 |
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 181 |
uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 182 | 182 |
{
|
| 183 |
bits64 z0, z1;
|
|
| 183 |
uint64_t z0, z1;
|
|
| 184 | 184 |
int8 negCount = ( - count ) & 63; |
| 185 | 185 |
|
| 186 | 186 |
if ( count == 0 ) {
|
| ... | ... | |
| 229 | 229 |
|
| 230 | 230 |
INLINE void |
| 231 | 231 |
shift128ExtraRightJamming( |
| 232 |
bits64 a0,
|
|
| 233 |
bits64 a1,
|
|
| 234 |
bits64 a2,
|
|
| 232 |
uint64_t a0,
|
|
| 233 |
uint64_t a1,
|
|
| 234 |
uint64_t a2,
|
|
| 235 | 235 |
int16 count, |
| 236 |
bits64 *z0Ptr,
|
|
| 237 |
bits64 *z1Ptr,
|
|
| 238 |
bits64 *z2Ptr
|
|
| 236 |
uint64_t *z0Ptr,
|
|
| 237 |
uint64_t *z1Ptr,
|
|
| 238 |
uint64_t *z2Ptr
|
|
| 239 | 239 |
) |
| 240 | 240 |
{
|
| 241 |
bits64 z0, z1, z2;
|
|
| 241 |
uint64_t z0, z1, z2;
|
|
| 242 | 242 |
int8 negCount = ( - count ) & 63; |
| 243 | 243 |
|
| 244 | 244 |
if ( count == 0 ) {
|
| ... | ... | |
| 287 | 287 |
|
| 288 | 288 |
INLINE void |
| 289 | 289 |
shortShift128Left( |
| 290 |
bits64 a0, bits64 a1, int16 count, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 290 |
uint64_t a0, uint64_t a1, int16 count, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 291 | 291 |
{
|
| 292 | 292 |
|
| 293 | 293 |
*z1Ptr = a1<<count; |
| ... | ... | |
| 306 | 306 |
|
| 307 | 307 |
INLINE void |
| 308 | 308 |
shortShift192Left( |
| 309 |
bits64 a0,
|
|
| 310 |
bits64 a1,
|
|
| 311 |
bits64 a2,
|
|
| 309 |
uint64_t a0,
|
|
| 310 |
uint64_t a1,
|
|
| 311 |
uint64_t a2,
|
|
| 312 | 312 |
int16 count, |
| 313 |
bits64 *z0Ptr,
|
|
| 314 |
bits64 *z1Ptr,
|
|
| 315 |
bits64 *z2Ptr
|
|
| 313 |
uint64_t *z0Ptr,
|
|
| 314 |
uint64_t *z1Ptr,
|
|
| 315 |
uint64_t *z2Ptr
|
|
| 316 | 316 |
) |
| 317 | 317 |
{
|
| 318 |
bits64 z0, z1, z2;
|
|
| 318 |
uint64_t z0, z1, z2;
|
|
| 319 | 319 |
int8 negCount; |
| 320 | 320 |
|
| 321 | 321 |
z2 = a2<<count; |
| ... | ... | |
| 341 | 341 |
|
| 342 | 342 |
INLINE void |
| 343 | 343 |
add128( |
| 344 |
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 344 |
uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 345 | 345 |
{
|
| 346 |
bits64 z1;
|
|
| 346 |
uint64_t z1;
|
|
| 347 | 347 |
|
| 348 | 348 |
z1 = a1 + b1; |
| 349 | 349 |
*z1Ptr = z1; |
| ... | ... | |
| 361 | 361 |
|
| 362 | 362 |
INLINE void |
| 363 | 363 |
add192( |
| 364 |
bits64 a0,
|
|
| 365 |
bits64 a1,
|
|
| 366 |
bits64 a2,
|
|
| 367 |
bits64 b0,
|
|
| 368 |
bits64 b1,
|
|
| 369 |
bits64 b2,
|
|
| 370 |
bits64 *z0Ptr,
|
|
| 371 |
bits64 *z1Ptr,
|
|
| 372 |
bits64 *z2Ptr
|
|
| 364 |
uint64_t a0,
|
|
| 365 |
uint64_t a1,
|
|
| 366 |
uint64_t a2,
|
|
| 367 |
uint64_t b0,
|
|
| 368 |
uint64_t b1,
|
|
| 369 |
uint64_t b2,
|
|
| 370 |
uint64_t *z0Ptr,
|
|
| 371 |
uint64_t *z1Ptr,
|
|
| 372 |
uint64_t *z2Ptr
|
|
| 373 | 373 |
) |
| 374 | 374 |
{
|
| 375 |
bits64 z0, z1, z2;
|
|
| 375 |
uint64_t z0, z1, z2;
|
|
| 376 | 376 |
int8 carry0, carry1; |
| 377 | 377 |
|
| 378 | 378 |
z2 = a2 + b2; |
| ... | ... | |
| 399 | 399 |
|
| 400 | 400 |
INLINE void |
| 401 | 401 |
sub128( |
| 402 |
bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 402 |
uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 403 | 403 |
{
|
| 404 | 404 |
|
| 405 | 405 |
*z1Ptr = a1 - b1; |
| ... | ... | |
| 417 | 417 |
|
| 418 | 418 |
INLINE void |
| 419 | 419 |
sub192( |
| 420 |
bits64 a0,
|
|
| 421 |
bits64 a1,
|
|
| 422 |
bits64 a2,
|
|
| 423 |
bits64 b0,
|
|
| 424 |
bits64 b1,
|
|
| 425 |
bits64 b2,
|
|
| 426 |
bits64 *z0Ptr,
|
|
| 427 |
bits64 *z1Ptr,
|
|
| 428 |
bits64 *z2Ptr
|
|
| 420 |
uint64_t a0,
|
|
| 421 |
uint64_t a1,
|
|
| 422 |
uint64_t a2,
|
|
| 423 |
uint64_t b0,
|
|
| 424 |
uint64_t b1,
|
|
| 425 |
uint64_t b2,
|
|
| 426 |
uint64_t *z0Ptr,
|
|
| 427 |
uint64_t *z1Ptr,
|
|
| 428 |
uint64_t *z2Ptr
|
|
| 429 | 429 |
) |
| 430 | 430 |
{
|
| 431 |
bits64 z0, z1, z2;
|
|
| 431 |
uint64_t z0, z1, z2;
|
|
| 432 | 432 |
int8 borrow0, borrow1; |
| 433 | 433 |
|
| 434 | 434 |
z2 = a2 - b2; |
| ... | ... | |
| 451 | 451 |
| `z0Ptr' and `z1Ptr'. |
| 452 | 452 |
*----------------------------------------------------------------------------*/ |
| 453 | 453 |
|
| 454 |
INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )
|
|
| 454 |
INLINE void mul64To128( uint64_t a, uint64_t b, uint64_t *z0Ptr, uint64_t *z1Ptr )
|
|
| 455 | 455 |
{
|
| 456 |
bits32 aHigh, aLow, bHigh, bLow;
|
|
| 457 |
bits64 z0, zMiddleA, zMiddleB, z1;
|
|
| 456 |
uint32_t aHigh, aLow, bHigh, bLow;
|
|
| 457 |
uint64_t z0, zMiddleA, zMiddleB, z1;
|
|
| 458 | 458 |
|
| 459 | 459 |
aLow = a; |
| 460 | 460 |
aHigh = a>>32; |
| 461 | 461 |
bLow = b; |
| 462 | 462 |
bHigh = b>>32; |
| 463 |
z1 = ( (bits64) aLow ) * bLow;
|
|
| 464 |
zMiddleA = ( (bits64) aLow ) * bHigh;
|
|
| 465 |
zMiddleB = ( (bits64) aHigh ) * bLow;
|
|
| 466 |
z0 = ( (bits64) aHigh ) * bHigh;
|
|
| 463 |
z1 = ( (uint64_t) aLow ) * bLow;
|
|
| 464 |
zMiddleA = ( (uint64_t) aLow ) * bHigh;
|
|
| 465 |
zMiddleB = ( (uint64_t) aHigh ) * bLow;
|
|
| 466 |
z0 = ( (uint64_t) aHigh ) * bHigh;
|
|
| 467 | 467 |
zMiddleA += zMiddleB; |
| 468 |
z0 += ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
|
|
| 468 |
z0 += ( ( (uint64_t) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );
|
|
| 469 | 469 |
zMiddleA <<= 32; |
| 470 | 470 |
z1 += zMiddleA; |
| 471 | 471 |
z0 += ( z1 < zMiddleA ); |
| ... | ... | |
| 483 | 483 |
|
| 484 | 484 |
INLINE void |
| 485 | 485 |
mul128By64To192( |
| 486 |
bits64 a0,
|
|
| 487 |
bits64 a1,
|
|
| 488 |
bits64 b,
|
|
| 489 |
bits64 *z0Ptr,
|
|
| 490 |
bits64 *z1Ptr,
|
|
| 491 |
bits64 *z2Ptr
|
|
| 486 |
uint64_t a0,
|
|
| 487 |
uint64_t a1,
|
|
| 488 |
uint64_t b,
|
|
| 489 |
uint64_t *z0Ptr,
|
|
| 490 |
uint64_t *z1Ptr,
|
|
| 491 |
uint64_t *z2Ptr
|
|
| 492 | 492 |
) |
| 493 | 493 |
{
|
| 494 |
bits64 z0, z1, z2, more1;
|
|
| 494 |
uint64_t z0, z1, z2, more1;
|
|
| 495 | 495 |
|
| 496 | 496 |
mul64To128( a1, b, &z1, &z2 ); |
| 497 | 497 |
mul64To128( a0, b, &z0, &more1 ); |
| ... | ... | |
| 511 | 511 |
|
| 512 | 512 |
INLINE void |
| 513 | 513 |
mul128To256( |
| 514 |
bits64 a0,
|
|
| 515 |
bits64 a1,
|
|
| 516 |
bits64 b0,
|
|
| 517 |
bits64 b1,
|
|
| 518 |
bits64 *z0Ptr,
|
|
| 519 |
bits64 *z1Ptr,
|
|
| 520 |
bits64 *z2Ptr,
|
|
| 521 |
bits64 *z3Ptr
|
|
| 514 |
uint64_t a0,
|
|
| 515 |
uint64_t a1,
|
|
| 516 |
uint64_t b0,
|
|
| 517 |
uint64_t b1,
|
|
| 518 |
uint64_t *z0Ptr,
|
|
| 519 |
uint64_t *z1Ptr,
|
|
| 520 |
uint64_t *z2Ptr,
|
|
| 521 |
uint64_t *z3Ptr
|
|
| 522 | 522 |
) |
| 523 | 523 |
{
|
| 524 |
bits64 z0, z1, z2, z3;
|
|
| 525 |
bits64 more1, more2;
|
|
| 524 |
uint64_t z0, z1, z2, z3;
|
|
| 525 |
uint64_t more1, more2;
|
|
| 526 | 526 |
|
| 527 | 527 |
mul64To128( a1, b1, &z2, &z3 ); |
| 528 | 528 |
mul64To128( a1, b0, &z1, &more2 ); |
| ... | ... | |
| 548 | 548 |
| unsigned integer is returned. |
| 549 | 549 |
*----------------------------------------------------------------------------*/ |
| 550 | 550 |
|
| 551 |
static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b )
|
|
| 551 |
static uint64_t estimateDiv128To64( uint64_t a0, uint64_t a1, uint64_t b )
|
|
| 552 | 552 |
{
|
| 553 |
bits64 b0, b1;
|
|
| 554 |
bits64 rem0, rem1, term0, term1;
|
|
| 555 |
bits64 z;
|
|
| 553 |
uint64_t b0, b1;
|
|
| 554 |
uint64_t rem0, rem1, term0, term1;
|
|
| 555 |
uint64_t z;
|
|
| 556 | 556 |
|
| 557 | 557 |
if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF ); |
| 558 | 558 |
b0 = b>>32; |
| 559 | 559 |
z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32; |
| 560 | 560 |
mul64To128( b, z, &term0, &term1 ); |
| 561 | 561 |
sub128( a0, a1, term0, term1, &rem0, &rem1 ); |
| 562 |
while ( ( (sbits64) rem0 ) < 0 ) {
|
|
| 562 |
while ( ( (int64_t) rem0 ) < 0 ) {
|
|
| 563 | 563 |
z -= LIT64( 0x100000000 ); |
| 564 | 564 |
b1 = b<<32; |
| 565 | 565 |
add128( rem0, rem1, b0, b1, &rem0, &rem1 ); |
| ... | ... | |
| 580 | 580 |
| value. |
| 581 | 581 |
*----------------------------------------------------------------------------*/ |
| 582 | 582 |
|
| 583 |
static bits32 estimateSqrt32( int16 aExp, bits32 a )
|
|
| 583 |
static uint32_t estimateSqrt32( int16 aExp, uint32_t a )
|
|
| 584 | 584 |
{
|
| 585 |
static const bits16 sqrtOddAdjustments[] = {
|
|
| 585 |
static const uint16_t sqrtOddAdjustments[] = {
|
|
| 586 | 586 |
0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0, |
| 587 | 587 |
0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67 |
| 588 | 588 |
}; |
| 589 |
static const bits16 sqrtEvenAdjustments[] = {
|
|
| 589 |
static const uint16_t sqrtEvenAdjustments[] = {
|
|
| 590 | 590 |
0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, |
| 591 | 591 |
0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 |
| 592 | 592 |
}; |
| 593 | 593 |
int8 index; |
| 594 |
bits32 z;
|
|
| 594 |
uint32_t z;
|
|
| 595 | 595 |
|
| 596 | 596 |
index = ( a>>27 ) & 15; |
| 597 | 597 |
if ( aExp & 1 ) {
|
| ... | ... | |
| 603 | 603 |
z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ (int)index ]; |
| 604 | 604 |
z = a / z + z; |
| 605 | 605 |
z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 ); |
| 606 |
if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );
|
|
| 606 |
if ( z <= a ) return (uint32_t) ( ( (int32_t) a )>>1 );
|
|
| 607 | 607 |
} |
| 608 |
return ( (bits32) ( ( ( (bits64) a )<<31 ) / z ) ) + ( z>>1 );
|
|
| 608 |
return ( (uint32_t) ( ( ( (uint64_t) a )<<31 ) / z ) ) + ( z>>1 );
|
|
| 609 | 609 |
|
| 610 | 610 |
} |
| 611 | 611 |
|
| ... | ... | |
| 614 | 614 |
| `a'. If `a' is zero, 32 is returned. |
| 615 | 615 |
*----------------------------------------------------------------------------*/ |
| 616 | 616 |
|
| 617 |
static int8 countLeadingZeros32( bits32 a )
|
|
| 617 |
static int8 countLeadingZeros32( uint32_t a )
|
|
| 618 | 618 |
{
|
| 619 | 619 |
static const int8 countLeadingZerosHigh[] = {
|
| 620 | 620 |
8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, |
| ... | ... | |
| 655 | 655 |
| `a'. If `a' is zero, 64 is returned. |
| 656 | 656 |
*----------------------------------------------------------------------------*/ |
| 657 | 657 |
|
| 658 |
static int8 countLeadingZeros64( bits64 a )
|
|
| 658 |
static int8 countLeadingZeros64( uint64_t a )
|
|
| 659 | 659 |
{
|
| 660 | 660 |
int8 shiftCount; |
| 661 | 661 |
|
| 662 | 662 |
shiftCount = 0; |
| 663 |
if ( a < ( (bits64) 1 )<<32 ) {
|
|
| 663 |
if ( a < ( (uint64_t) 1 )<<32 ) {
|
|
| 664 | 664 |
shiftCount += 32; |
| 665 | 665 |
} |
| 666 | 666 |
else {
|
| ... | ... | |
| 677 | 677 |
| Otherwise, returns 0. |
| 678 | 678 |
*----------------------------------------------------------------------------*/ |
| 679 | 679 |
|
| 680 |
INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
| 680 |
INLINE flag eq128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
|
|
| 681 | 681 |
{
|
| 682 | 682 |
|
| 683 | 683 |
return ( a0 == b0 ) && ( a1 == b1 ); |
| ... | ... | |
| 690 | 690 |
| Otherwise, returns 0. |
| 691 | 691 |
*----------------------------------------------------------------------------*/ |
| 692 | 692 |
|
| 693 |
INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
| 693 |
INLINE flag le128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
|
|
| 694 | 694 |
{
|
| 695 | 695 |
|
| 696 | 696 |
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) ); |
| ... | ... | |
| 703 | 703 |
| returns 0. |
| 704 | 704 |
*----------------------------------------------------------------------------*/ |
| 705 | 705 |
|
| 706 |
INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
| 706 |
INLINE flag lt128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
|
|
| 707 | 707 |
{
|
| 708 | 708 |
|
| 709 | 709 |
return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) ); |
| ... | ... | |
| 716 | 716 |
| Otherwise, returns 0. |
| 717 | 717 |
*----------------------------------------------------------------------------*/ |
| 718 | 718 |
|
| 719 |
INLINE flag ne128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )
|
|
| 719 |
INLINE flag ne128( uint64_t a0, uint64_t a1, uint64_t b0, uint64_t b1 )
|
|
| 720 | 720 |
{
|
| 721 | 721 |
|
| 722 | 722 |
return ( a0 != b0 ) || ( a1 != b1 ); |
Also available in: Unified diff