primitives.h File Reference

#include <stdbool.h>
#include <stdint.h>
#include "primitiveTypes.h"

Include dependency graph for primitives.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	softfloat_shortShiftLeft96M(aPtr, dist, zPtr)
#define	softfloat_shortShiftLeft128M(aPtr, dist, zPtr)
#define	softfloat_shortShiftLeft160M(aPtr, dist, zPtr)
#define	softfloat_shiftLeft96M(aPtr, dist, zPtr)
#define	softfloat_shiftLeft128M(aPtr, dist, zPtr)
#define	softfloat_shiftLeft160M(aPtr, dist, zPtr)
#define	softfloat_shortShiftRight128M(aPtr, dist, zPtr)
#define	softfloat_shortShiftRight160M(aPtr, dist, zPtr)
#define	softfloat_shortShiftRightJam160M(aPtr, dist, zPtr)
#define	softfloat_shiftRight96M(aPtr, dist, zPtr)
#define	softfloat_shiftRightJam96M(aPtr, dist, zPtr)
#define	softfloat_shiftRightJam128M(aPtr, dist, zPtr)
#define	softfloat_shiftRightJam160M(aPtr, dist, zPtr)
#define	softfloat_add96M(aPtr, bPtr, zPtr)
#define	softfloat_add128M(aPtr, bPtr, zPtr)
#define	softfloat_add160M(aPtr, bPtr, zPtr)
#define	softfloat_addComplCarry96M(aPtr, bPtr, carry, zPtr)
#define	softfloat_negX96M(zPtr)
#define	softfloat_negX128M(zPtr)
#define	softfloat_negX160M(zPtr)
#define	softfloat_negX256M(zPtr)
#define	softfloat_sub1X96M(zPtr)
#define	softfloat_sub1X160M(zPtr)
#define	softfloat_sub96M(aPtr, bPtr, zPtr)
#define	softfloat_sub128M(aPtr, bPtr, zPtr)
#define	softfloat_sub160M(aPtr, bPtr, zPtr)
#define	softfloat_remStep96MBy32(remPtr, dist, bPtr, q, zPtr)
#define	softfloat_remStep128MBy32(remPtr, dist, bPtr, q, zPtr)
#define	softfloat_remStep160MBy32(remPtr, dist, bPtr, q, zPtr)

Functions
uint64_t	softfloat_shortShiftRightJam64 (uint64_t a, uint_fast8_t dist)
uint32_t	softfloat_shiftRightJam32 (uint32_t a, uint_fast16_t dist)
uint64_t	softfloat_shiftRightJam64 (uint64_t a, uint_fast32_t dist)
uint_fast8_t	softfloat_countLeadingZeros16 (uint16_t a)
uint_fast8_t	softfloat_countLeadingZeros32 (uint32_t a)
uint_fast8_t	softfloat_countLeadingZeros64 (uint64_t a)
uint32_t	softfloat_approxRecip32_1 (uint32_t a)
uint32_t	softfloat_approxRecipSqrt32_1 (unsigned int oddExpA, uint32_t a)
int_fast8_t	softfloat_compare96M (const uint32_t *aPtr, const uint32_t *bPtr)
int_fast8_t	softfloat_compare128M (const uint32_t *aPtr, const uint32_t *bPtr)
void	softfloat_shortShiftLeft64To96M (uint64_t a, uint_fast8_t dist, uint32_t *zPtr)
void	softfloat_shortShiftLeftM (uint_fast8_t size_words, const uint32_t *aPtr, uint_fast8_t dist, uint32_t *zPtr)
void	softfloat_shiftLeftM (uint_fast8_t size_words, const uint32_t *aPtr, uint32_t dist, uint32_t *zPtr)
void	softfloat_shortShiftRightM (uint_fast8_t size_words, const uint32_t *aPtr, uint_fast8_t dist, uint32_t *zPtr)
void	softfloat_shortShiftRightJamM (uint_fast8_t, const uint32_t *, uint_fast8_t, uint32_t *)
void	softfloat_shiftRightM (uint_fast8_t size_words, const uint32_t *aPtr, uint32_t dist, uint32_t *zPtr)
void	softfloat_shiftRightJamM (uint_fast8_t size_words, const uint32_t *aPtr, uint32_t dist, uint32_t *zPtr)
void	softfloat_addM (uint_fast8_t size_words, const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr)
uint_fast8_t	softfloat_addCarryM (uint_fast8_t size_words, const uint32_t *aPtr, const uint32_t *bPtr, uint_fast8_t carry, uint32_t *zPtr)
uint_fast8_t	softfloat_addComplCarryM (uint_fast8_t size_words, const uint32_t *aPtr, const uint32_t *bPtr, uint_fast8_t carry, uint32_t *zPtr)
void	softfloat_negXM (uint_fast8_t size_words, uint32_t *zPtr)
void	softfloat_sub1XM (uint_fast8_t size_words, uint32_t *zPtr)
void	softfloat_subM (uint_fast8_t size_words, const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr)
void	softfloat_mul64To128M (uint64_t a, uint64_t b, uint32_t *zPtr)
void	softfloat_mul128MTo256M (const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr)
void	softfloat_remStepMBy32 (uint_fast8_t size_words, const uint32_t *remPtr, uint_fast8_t dist, const uint32_t *bPtr, uint32_t q, uint32_t *zPtr)

Variables
const uint_least8_t	softfloat_countLeadingZeros8 [256]
const uint16_t	softfloat_approxRecip_1k0s [16]
const uint16_t	softfloat_approxRecip_1k1s [16]
const uint16_t	softfloat_approxRecipSqrt_1k0s [16]
const uint16_t	softfloat_approxRecipSqrt_1k1s [16]

Macro Definition Documentation

softfloat_add128M

#define softfloat_add128M	(		aPtr,
			bPtr,
			zPtr )

Value:

softfloat_addM( 4, aPtr, bPtr, zPtr )

Definition at line 923 of file primitives.h.

softfloat_add160M

#define softfloat_add160M	(		aPtr,
			bPtr,
			zPtr )

Value:

softfloat_addM( 5, aPtr, bPtr, zPtr )

Definition at line 931 of file primitives.h.

softfloat_add96M

#define softfloat_add96M	(		aPtr,
			bPtr,
			zPtr )

Value:

softfloat_addM( 3, aPtr, bPtr, zPtr )

Definition at line 915 of file primitives.h.

softfloat_addComplCarry96M

#define softfloat_addComplCarry96M	(		aPtr,
			bPtr,
			carry,
			zPtr )

Value:

softfloat_addComplCarryM( 3, aPtr, bPtr, carry, zPtr )

Definition at line 974 of file primitives.h.

softfloat_negX128M

#define softfloat_negX128M

(

zPtr

)

Value:

softfloat_negXM( 4, zPtr )

Definition at line 1000 of file primitives.h.

softfloat_negX160M

#define softfloat_negX160M

(

zPtr

)

Value:

softfloat_negXM( 5, zPtr )

Definition at line 1008 of file primitives.h.

softfloat_negX256M

#define softfloat_negX256M

(

zPtr

)

Value:

softfloat_negXM( 8, zPtr )

Definition at line 1016 of file primitives.h.

softfloat_negX96M

#define softfloat_negX96M

(

zPtr

)

Value:

softfloat_negXM( 3, zPtr )

Definition at line 992 of file primitives.h.

softfloat_remStep128MBy32

#define softfloat_remStep128MBy32	(		remPtr,
			dist,
			bPtr,
			q,
			zPtr )

Value:

softfloat_remStepMBy32( 4, remPtr, dist, bPtr, q, zPtr )

Definition at line 1146 of file primitives.h.

softfloat_remStep160MBy32

#define softfloat_remStep160MBy32	(		remPtr,
			dist,
			bPtr,
			q,
			zPtr )

Value:

softfloat_remStepMBy32( 5, remPtr, dist, bPtr, q, zPtr )

Definition at line 1154 of file primitives.h.

softfloat_remStep96MBy32

#define softfloat_remStep96MBy32	(		remPtr,
			dist,
			bPtr,
			q,
			zPtr )

Value:

softfloat_remStepMBy32( 3, remPtr, dist, bPtr, q, zPtr )

Definition at line 1138 of file primitives.h.

softfloat_shiftLeft128M

#define softfloat_shiftLeft128M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftLeftM( 4, aPtr, dist, zPtr )

Definition at line 747 of file primitives.h.

softfloat_shiftLeft160M

#define softfloat_shiftLeft160M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftLeftM( 5, aPtr, dist, zPtr )

Definition at line 755 of file primitives.h.

softfloat_shiftLeft96M

#define softfloat_shiftLeft96M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftLeftM( 3, aPtr, dist, zPtr )

Definition at line 739 of file primitives.h.

softfloat_shiftRight96M

#define softfloat_shiftRight96M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftRightM( 3, aPtr, dist, zPtr )

Definition at line 842 of file primitives.h.

softfloat_shiftRightJam128M

#define softfloat_shiftRightJam128M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftRightJamM( 4, aPtr, dist, zPtr )

Definition at line 881 of file primitives.h.

softfloat_shiftRightJam160M

#define softfloat_shiftRightJam160M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftRightJamM( 5, aPtr, dist, zPtr )

Definition at line 889 of file primitives.h.

softfloat_shiftRightJam96M

#define softfloat_shiftRightJam96M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shiftRightJamM( 3, aPtr, dist, zPtr )

Definition at line 873 of file primitives.h.

softfloat_shortShiftLeft128M

#define softfloat_shortShiftLeft128M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shortShiftLeftM( 4, aPtr, dist, zPtr )

Definition at line 703 of file primitives.h.

softfloat_shortShiftLeft160M

#define softfloat_shortShiftLeft160M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shortShiftLeftM( 5, aPtr, dist, zPtr )

Definition at line 711 of file primitives.h.

softfloat_shortShiftLeft96M

#define softfloat_shortShiftLeft96M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shortShiftLeftM( 3, aPtr, dist, zPtr )

Definition at line 695 of file primitives.h.

softfloat_shortShiftRight128M

#define softfloat_shortShiftRight128M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shortShiftRightM( 4, aPtr, dist, zPtr )

Definition at line 782 of file primitives.h.

softfloat_shortShiftRight160M

#define softfloat_shortShiftRight160M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shortShiftRightM( 5, aPtr, dist, zPtr )

Definition at line 790 of file primitives.h.

softfloat_shortShiftRightJam160M

#define softfloat_shortShiftRightJam160M	(		aPtr,
			dist,
			zPtr )

Value:

softfloat_shortShiftRightJamM( 5, aPtr, dist, zPtr )

Definition at line 814 of file primitives.h.

softfloat_sub128M

#define softfloat_sub128M	(		aPtr,
			bPtr,
			zPtr )

Value:

softfloat_subM( 4, aPtr, bPtr, zPtr )

Definition at line 1077 of file primitives.h.

softfloat_sub160M

#define softfloat_sub160M	(		aPtr,
			bPtr,
			zPtr )

Value:

softfloat_subM( 5, aPtr, bPtr, zPtr )

Definition at line 1085 of file primitives.h.

softfloat_sub1X160M

#define softfloat_sub1X160M

(

zPtr

)

Value:

softfloat_sub1XM( 5, zPtr )

Definition at line 1043 of file primitives.h.

softfloat_sub1X96M

#define softfloat_sub1X96M

(

zPtr

)

Value:

softfloat_sub1XM( 3, zPtr )

Definition at line 1035 of file primitives.h.

softfloat_sub96M

#define softfloat_sub96M	(		aPtr,
			bPtr,
			zPtr )

Value:

softfloat_subM( 3, aPtr, bPtr, zPtr )

Definition at line 1069 of file primitives.h.

Function Documentation

softfloat_addCarryM()

uint_fast8_t softfloat_addCarryM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		const uint32_t *	bPtr,
		uint_fast8_t	carry,
		uint32_t *	zPtr )

Definition at line 44 of file s_addCarryM.c.

{
    unsigned int index, lastIndex;
    uint32_t wordA, wordZ;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    for (;;) {
        wordA = aPtr[index];
        wordZ = wordA + bPtr[index] + carry;
        zPtr[index] = wordZ;
        if ( wordZ != wordA ) carry = (wordZ < wordA);
        if ( index == lastIndex ) break;
        index += wordIncr;
    }
    return carry;
 
}

Here is the caller graph for this function:

softfloat_addComplCarryM()

uint_fast8_t softfloat_addComplCarryM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		const uint32_t *	bPtr,
		uint_fast8_t	carry,
		uint32_t *	zPtr )

Definition at line 44 of file s_addComplCarryM.c.

{
    unsigned int index, lastIndex;
    uint32_t wordA, wordZ;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    for (;;) {
        wordA = aPtr[index];
        wordZ = wordA + ~bPtr[index] + carry;
        zPtr[index] = wordZ;
        if ( wordZ != wordA ) carry = (wordZ < wordA);
        if ( index == lastIndex ) break;
        index += wordIncr;
    }
    return carry;
 
}

Here is the caller graph for this function:

softfloat_addM()

void softfloat_addM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		const uint32_t *	bPtr,
		uint32_t *	zPtr )

Definition at line 44 of file s_addM.c.

{
    unsigned int index, lastIndex;
    uint_fast8_t carry;
    uint32_t wordA, wordZ;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    carry = 0;
    for (;;) {
        wordA = aPtr[index];
        wordZ = wordA + bPtr[index] + carry;
        zPtr[index] = wordZ;
        if ( index == lastIndex ) break;
        if ( wordZ != wordA ) carry = (wordZ < wordA);
        index += wordIncr;
    }
 
}

softfloat_approxRecip32_1()

uint32_t softfloat_approxRecip32_1

(

uint32_t

a

)

Definition at line 45 of file s_approxRecip32_1.c.

{
    int index;
    uint16_t eps, r0;
    uint32_t sigma0;
    uint_fast32_t r;
    uint32_t sqrSigma0;
 
    index = a>>27 & 0xF;
    eps = (uint16_t) (a>>11);
    r0 = softfloat_approxRecip_1k0s[index]
             - ((softfloat_approxRecip_1k1s[index] * (uint_fast32_t) eps)>>20);
    sigma0 = ~(uint_fast32_t) ((r0 * (uint_fast64_t) a)>>7);
    r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>24);
    sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;
    r += ((uint32_t) r * (uint_fast64_t) sqrSigma0)>>48;
    return r;
 
}

Here is the caller graph for this function:

softfloat_approxRecipSqrt32_1()

uint32_t softfloat_approxRecipSqrt32_1	(	unsigned int	oddExpA,
		uint32_t	a )

Definition at line 45 of file s_approxRecipSqrt32_1.c.

{
    int index;
    uint16_t eps, r0;
    uint_fast32_t ESqrR0;
    uint32_t sigma0;
    uint_fast32_t r;
    uint32_t sqrSigma0;
 
    index = (a>>27 & 0xE) + oddExpA;
    eps = (uint16_t) (a>>12);
    r0 = softfloat_approxRecipSqrt_1k0s[index]
             - ((softfloat_approxRecipSqrt_1k1s[index] * (uint_fast32_t) eps)
                    >>20);
    ESqrR0 = (uint_fast32_t) r0 * r0;
    if ( ! oddExpA ) ESqrR0 <<= 1;
    sigma0 = ~(uint_fast32_t) (((uint32_t) ESqrR0 * (uint_fast64_t) a)>>23);
    r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>25);
    sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;
    r += ((uint32_t) ((r>>1) + (r>>3) - ((uint_fast32_t) r0<<14))
              * (uint_fast64_t) sqrSigma0)
             >>48;
    if ( ! (r & 0x80000000) ) r = 0x80000000;
    return r;
 
}

Here is the caller graph for this function:

softfloat_compare128M()

int_fast8_t softfloat_compare128M	(	const uint32_t *	aPtr,
		const uint32_t *	bPtr )

Definition at line 43 of file s_compare128M.c.

{
    unsigned int index, lastIndex;
    uint32_t wordA, wordB;
 
    index = indexWordHi( 4 );
    lastIndex = indexWordLo( 4 );
    for (;;) {
        wordA = aPtr[index];
        wordB = bPtr[index];
        if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1;
        if ( index == lastIndex ) break;
        index -= wordIncr;
    }
    return 0;
 
}

Here is the caller graph for this function:

softfloat_compare96M()

int_fast8_t softfloat_compare96M	(	const uint32_t *	aPtr,
		const uint32_t *	bPtr )

Definition at line 43 of file s_compare96M.c.

{
    unsigned int index, lastIndex;
    uint32_t wordA, wordB;
 
    index = indexWordHi( 3 );
    lastIndex = indexWordLo( 3 );
    for (;;) {
        wordA = aPtr[index];
        wordB = bPtr[index];
        if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1;
        if ( index == lastIndex ) break;
        index -= wordIncr;
    }
    return 0;
 
}

Here is the caller graph for this function:

softfloat_countLeadingZeros16()

uint_fast8_t softfloat_countLeadingZeros16

(

uint16_t

a

)

Definition at line 45 of file s_countLeadingZeros16.c.

{
    uint_fast8_t count;
 
    count = 8;
    if ( 0x100 <= a ) {
        count = 0;
        a >>= 8;
    }
    count += softfloat_countLeadingZeros8[a];
    return count;
 
}

softfloat_countLeadingZeros32()

uint_fast8_t softfloat_countLeadingZeros32

(

uint32_t

a

)

Definition at line 45 of file s_countLeadingZeros32.c.

{
    uint_fast8_t count;
 
    count = 0;
    if ( a < 0x10000 ) {
        count = 16;
        a <<= 16;
    }
    if ( a < 0x1000000 ) {
        count += 8;
        a <<= 8;
    }
    count += softfloat_countLeadingZeros8[a>>24];
    return count;
 
}

softfloat_countLeadingZeros64()

uint_fast8_t softfloat_countLeadingZeros64

(

uint64_t

a

)

Definition at line 45 of file s_countLeadingZeros64.c.

{
    uint_fast8_t count;
    uint32_t a32;
 
    count = 0;
    a32 = a>>32;
    if ( ! a32 ) {
        count = 32;
        a32 = a;
    }
    /*------------------------------------------------------------------------
    | From here, result is current count + count leading zeros of `a32'.
    *------------------------------------------------------------------------*/
    if ( a32 < 0x10000 ) {
        count += 16;
        a32 <<= 16;
    }
    if ( a32 < 0x1000000 ) {
        count += 8;
        a32 <<= 8;
    }
    count += softfloat_countLeadingZeros8[a32>>24];
    return count;
 
}

softfloat_mul128MTo256M()

void softfloat_mul128MTo256M	(	const uint32_t *	aPtr,
		const uint32_t *	bPtr,
		uint32_t *	zPtr )

Definition at line 44 of file s_mul128MTo256M.c.

{
    uint32_t *lastZPtr, wordB;
    uint64_t dwordProd;
    uint32_t wordZ;
    uint_fast8_t carry;
 
    bPtr += indexWordLo( 4 );
    lastZPtr = zPtr + indexMultiwordHi( 8, 5 );
    zPtr += indexMultiwordLo( 8, 5 );
    wordB = *bPtr;
    dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB;
    zPtr[indexWord( 5, 0 )] = dwordProd;
    dwordProd = (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32);
    zPtr[indexWord( 5, 1 )] = dwordProd;
    dwordProd = (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32);
    zPtr[indexWord( 5, 2 )] = dwordProd;
    dwordProd = (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32);
    zPtr[indexWord( 5, 3 )] = dwordProd;
    zPtr[indexWord( 5, 4 )] = dwordProd>>32;
    do {
        bPtr += wordIncr;
        zPtr += wordIncr;
        wordB = *bPtr;
        dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB;
        wordZ = zPtr[indexWord( 5, 0 )] + (uint32_t) dwordProd;
        zPtr[indexWord( 5, 0 )] = wordZ;
        carry = (wordZ < (uint32_t) dwordProd);
        dwordProd =
            (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32);
        wordZ = zPtr[indexWord( 5, 1 )] + (uint32_t) dwordProd + carry;
        zPtr[indexWord( 5, 1 )] = wordZ;
        if ( wordZ != (uint32_t) dwordProd ) {
            carry = (wordZ < (uint32_t) dwordProd);
        }
        dwordProd =
            (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32);
        wordZ = zPtr[indexWord( 5, 2 )] + (uint32_t) dwordProd + carry;
        zPtr[indexWord( 5, 2 )] = wordZ;
        if ( wordZ != (uint32_t) dwordProd ) {
            carry = (wordZ < (uint32_t) dwordProd);
        }
        dwordProd =
            (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32);
        wordZ = zPtr[indexWord( 5, 3 )] + (uint32_t) dwordProd + carry;
        zPtr[indexWord( 5, 3 )] = wordZ;
        if ( wordZ != (uint32_t) dwordProd ) {
            carry = (wordZ < (uint32_t) dwordProd);
        }
        zPtr[indexWord( 5, 4 )] = (dwordProd>>32) + carry;
    } while ( zPtr != lastZPtr );
 
}

Here is the caller graph for this function:

softfloat_mul64To128M()

void softfloat_mul64To128M	(	uint64_t	a,
		uint64_t	b,
		uint32_t *	zPtr )

Definition at line 43 of file s_mul64To128M.c.

{
    uint32_t a32, a0, b32, b0;
    uint64_t z0, mid1, z64, mid;
 
    a32 = a>>32;
    a0 = a;
    b32 = b>>32;
    b0 = b;
    z0 = (uint64_t) a0 * b0;
    mid1 = (uint64_t) a32 * b0;
    mid = mid1 + (uint64_t) a0 * b32;
    z64 = (uint64_t) a32 * b32;
    z64 += (uint64_t) (mid < mid1)<<32 | mid>>32;
    mid <<= 32;
    z0 += mid;
    zPtr[indexWord( 4, 1 )] = z0>>32;
    zPtr[indexWord( 4, 0 )] = z0;
    z64 += (z0 < mid);
    zPtr[indexWord( 4, 3 )] = z64>>32;
    zPtr[indexWord( 4, 2 )] = z64;
 
}

Here is the caller graph for this function:

softfloat_negXM()

void softfloat_negXM	(	uint_fast8_t	size_words,
		uint32_t *	zPtr )

Definition at line 43 of file s_negXM.c.

{
    unsigned int index, lastIndex;
    uint_fast8_t carry;
    uint32_t word;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    carry = 1;
    for (;;) {
        word = ~zPtr[index] + carry;
        zPtr[index] = word;
        if ( index == lastIndex ) break;
        index += wordIncr;
        if ( word ) carry = 0;
    }
 
}

softfloat_remStepMBy32()

void softfloat_remStepMBy32	(	uint_fast8_t	size_words,
		const uint32_t *	remPtr,
		uint_fast8_t	dist,
		const uint32_t *	bPtr,
		uint32_t	q,
		uint32_t *	zPtr )

Definition at line 44 of file s_remStepMBy32.c.

{
    unsigned int index, lastIndex;
    uint64_t dwordProd;
    uint32_t wordRem, wordShiftedRem, wordProd;
    uint_fast8_t uNegDist, borrow;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    dwordProd = (uint64_t) bPtr[index] * q;
    wordRem = remPtr[index];
    wordShiftedRem = wordRem<<dist;
    wordProd = dwordProd;
    zPtr[index] = wordShiftedRem - wordProd;
    if ( index != lastIndex ) {
        uNegDist = -dist;
        borrow = (wordShiftedRem < wordProd);
        for (;;) {
            wordShiftedRem = wordRem>>(uNegDist & 31);
            index += wordIncr;
            dwordProd = (uint64_t) bPtr[index] * q + (dwordProd>>32);
            wordRem = remPtr[index];
            wordShiftedRem |= wordRem<<dist;
            wordProd = dwordProd;
            zPtr[index] = wordShiftedRem - wordProd - borrow;
            if ( index == lastIndex ) break;
            borrow =
                borrow ? (wordShiftedRem <= wordProd)
                    : (wordShiftedRem < wordProd);
        }
    }
 
}

softfloat_shiftLeftM()

void softfloat_shiftLeftM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		uint32_t	dist,
		uint32_t *	zPtr )

Definition at line 46 of file s_shiftLeftM.c.

{
    uint32_t wordDist;
    uint_fast8_t innerDist;
    uint32_t *destPtr;
    uint_fast8_t i;
 
    wordDist = dist>>5;
    if ( wordDist < size_words ) {
        aPtr += indexMultiwordLoBut( size_words, wordDist );
        innerDist = dist & 31;
        if ( innerDist ) {
            softfloat_shortShiftLeftM(
                size_words - wordDist,
                aPtr,
                innerDist,
                zPtr + indexMultiwordHiBut( size_words, wordDist )
            );
            if ( ! wordDist ) return;
        } else {
            aPtr += indexWordHi( size_words - wordDist );
            destPtr = zPtr + indexWordHi( size_words );
            for ( i = size_words - wordDist; i; --i ) {
                *destPtr = *aPtr;
                aPtr -= wordIncr;
                destPtr -= wordIncr;
            }
        }
        zPtr += indexMultiwordLo( size_words, wordDist );
    } else {
        wordDist = size_words;
    }
    do {
        *zPtr++ = 0;
        --wordDist;
    } while ( wordDist );
 
}

Here is the call graph for this function:

softfloat_shiftRightJam32()

uint32_t softfloat_shiftRightJam32	(	uint32_t	a,
		uint_fast16_t	dist )

Definition at line 42 of file s_shiftRightJam32.c.

{
 
    return
        (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);
 
}

Here is the caller graph for this function:

softfloat_shiftRightJam64()

uint64_t softfloat_shiftRightJam64	(	uint64_t	a,
		uint_fast32_t	dist )

Definition at line 42 of file s_shiftRightJam64.c.

{
 
    return
        (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);
 
}

Here is the caller graph for this function:

softfloat_shiftRightJamM()

void softfloat_shiftRightJamM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		uint32_t	dist,
		uint32_t *	zPtr )

Definition at line 46 of file s_shiftRightJamM.c.

{
    uint32_t wordJam, wordDist, *ptr;
    uint_fast8_t i, innerDist;
 
    wordJam = 0;
    wordDist = dist>>5;
    if ( wordDist ) {
        if ( size_words < wordDist ) wordDist = size_words;
        ptr = (uint32_t *) (aPtr + indexMultiwordLo( size_words, wordDist ));
        i = wordDist;
        do {
            wordJam = *ptr++;
            if ( wordJam ) break;
            --i;
        } while ( i );
        ptr = zPtr;
    }
    if ( wordDist < size_words ) {
        aPtr += indexMultiwordHiBut( size_words, wordDist );
        innerDist = dist & 31;
        if ( innerDist ) {
            softfloat_shortShiftRightJamM(
                size_words - wordDist,
                aPtr,
                innerDist,
                zPtr + indexMultiwordLoBut( size_words, wordDist )
            );
            if ( ! wordDist ) goto wordJam;
        } else {
            aPtr += indexWordLo( size_words - wordDist );
            ptr = zPtr + indexWordLo( size_words );
            for ( i = size_words - wordDist; i; --i ) {
                *ptr = *aPtr;
                aPtr += wordIncr;
                ptr += wordIncr;
            }
        }
        ptr = zPtr + indexMultiwordHi( size_words, wordDist );
    }
    do {
        *ptr++ = 0;
        --wordDist;
    } while ( wordDist );
 wordJam:
    if ( wordJam ) zPtr[indexWordLo( size_words )] |= 1;
 
}

Here is the call graph for this function:

softfloat_shiftRightM()

void softfloat_shiftRightM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		uint32_t	dist,
		uint32_t *	zPtr )

Definition at line 46 of file s_shiftRightM.c.

{
    uint32_t wordDist;
    uint_fast8_t innerDist;
    uint32_t *destPtr;
    uint_fast8_t i;
 
    wordDist = dist>>5;
    if ( wordDist < size_words ) {
        aPtr += indexMultiwordHiBut( size_words, wordDist );
        innerDist = dist & 31;
        if ( innerDist ) {
            softfloat_shortShiftRightM(
                size_words - wordDist,
                aPtr,
                innerDist,
                zPtr + indexMultiwordLoBut( size_words, wordDist )
            );
            if ( ! wordDist ) return;
        } else {
            aPtr += indexWordLo( size_words - wordDist );
            destPtr = zPtr + indexWordLo( size_words );
            for ( i = size_words - wordDist; i; --i ) {
                *destPtr = *aPtr;
                aPtr += wordIncr;
                destPtr += wordIncr;
            }
        }
        zPtr += indexMultiwordHi( size_words, wordDist );
    } else {
        wordDist = size_words;
    }
    do {
        *zPtr++ = 0;
        --wordDist;
    } while ( wordDist );
 
}

Here is the call graph for this function:

softfloat_shortShiftLeft64To96M()

void softfloat_shortShiftLeft64To96M	(	uint64_t	a,
		uint_fast8_t	dist,
		uint32_t *	zPtr )

Definition at line 44 of file s_shortShiftLeft64To96M.c.

{
 
    zPtr[indexWord( 3, 0 )] = (uint32_t) a<<dist;
    a >>= 32 - dist;
    zPtr[indexWord( 3, 2 )] = a>>32;
    zPtr[indexWord( 3, 1 )] = a;
 
}

Here is the caller graph for this function:

softfloat_shortShiftLeftM()

void softfloat_shortShiftLeftM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		uint_fast8_t	dist,
		uint32_t *	zPtr )

Definition at line 44 of file s_shortShiftLeftM.c.

{
    uint_fast8_t uNegDist;
    unsigned int index, lastIndex;
    uint32_t partWordZ, wordA;
 
    uNegDist = -dist;
    index = indexWordHi( size_words );
    lastIndex = indexWordLo( size_words );
    partWordZ = aPtr[index]<<dist;
    while ( index != lastIndex ) {
        wordA = aPtr[index - wordIncr];
        zPtr[index] = partWordZ | wordA>>(uNegDist & 31);
        index -= wordIncr;
        partWordZ = wordA<<dist;
    }
    zPtr[index] = partWordZ;
 
}

Here is the caller graph for this function:

softfloat_shortShiftRightJam64()

uint64_t softfloat_shortShiftRightJam64	(	uint64_t	a,
		uint_fast8_t	dist )

Definition at line 42 of file s_shortShiftRightJam64.c.

{
 
    return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0);
 
}

Here is the caller graph for this function:

softfloat_shortShiftRightJamM()

void softfloat_shortShiftRightJamM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		uint_fast8_t	dist,
		uint32_t *	zPtr )

Definition at line 44 of file s_shortShiftRightJamM.c.

{
    uint_fast8_t uNegDist;
    unsigned int index, lastIndex;
    uint32_t partWordZ, wordA;
 
    uNegDist = -dist;
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    wordA = aPtr[index];
    partWordZ = wordA>>dist;
    if ( partWordZ<<dist != wordA ) partWordZ |= 1;
    while ( index != lastIndex ) {
        wordA = aPtr[index + wordIncr];
        zPtr[index] = wordA<<(uNegDist & 31) | partWordZ;
        index += wordIncr;
        partWordZ = wordA>>dist;
    }
    zPtr[index] = partWordZ;
 
}

Here is the caller graph for this function:

softfloat_shortShiftRightM()

void softfloat_shortShiftRightM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		uint_fast8_t	dist,
		uint32_t *	zPtr )

Definition at line 44 of file s_shortShiftRightM.c.

{
    uint_fast8_t uNegDist;
    unsigned int index, lastIndex;
    uint32_t partWordZ, wordA;
 
    uNegDist = -dist;
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    partWordZ = aPtr[index]>>dist;
    while ( index != lastIndex ) {
        wordA = aPtr[index + wordIncr];
        zPtr[index] = wordA<<(uNegDist & 31) | partWordZ;
        index += wordIncr;
        partWordZ = wordA>>dist;
    }
    zPtr[index] = partWordZ;
 
}

Here is the caller graph for this function:

softfloat_sub1XM()

void softfloat_sub1XM	(	uint_fast8_t	size_words,
		uint32_t *	zPtr )

Definition at line 43 of file s_sub1XM.c.

{
    unsigned int index, lastIndex;
    uint32_t wordA;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    for (;;) {
        wordA = zPtr[index];
        zPtr[index] = wordA - 1;
        if ( wordA || (index == lastIndex) ) break;
        index += wordIncr;
    }
 
}

softfloat_subM()

void softfloat_subM	(	uint_fast8_t	size_words,
		const uint32_t *	aPtr,
		const uint32_t *	bPtr,
		uint32_t *	zPtr )

Definition at line 44 of file s_subM.c.

{
    unsigned int index, lastIndex;
    uint_fast8_t borrow;
    uint32_t wordA, wordB;
 
    index = indexWordLo( size_words );
    lastIndex = indexWordHi( size_words );
    borrow = 0;
    for (;;) {
        wordA = aPtr[index];
        wordB = bPtr[index];
        zPtr[index] = wordA - wordB - borrow;
        if ( index == lastIndex ) break;
        borrow = borrow ? (wordA <= wordB) : (wordA < wordB);
        index += wordIncr;
    }
 
}

Variable Documentation

softfloat_approxRecip_1k0s

const uint16_t softfloat_approxRecip_1k0s[16]

extern

Definition at line 41 of file s_approxRecip_1Ks.c.

                                                {
    0xFFC4, 0xF0BE, 0xE363, 0xD76F, 0xCCAD, 0xC2F0, 0xBA16, 0xB201,
    0xAA97, 0xA3C6, 0x9D7A, 0x97A6, 0x923C, 0x8D32, 0x887E, 0x8417
};

softfloat_approxRecip_1k1s

const uint16_t softfloat_approxRecip_1k1s[16]

extern

Definition at line 45 of file s_approxRecip_1Ks.c.

                                                {
    0xF0F1, 0xD62C, 0xBFA1, 0xAC77, 0x9C0A, 0x8DDB, 0x8185, 0x76BA,
    0x6D3B, 0x64D4, 0x5D5C, 0x56B1, 0x50B6, 0x4B55, 0x4679, 0x4211
};

softfloat_approxRecipSqrt_1k0s

const uint16_t softfloat_approxRecipSqrt_1k0s[16]

extern

Definition at line 41 of file s_approxRecipSqrt_1Ks.c.

                                                    {
    0xB4C9, 0xFFAB, 0xAA7D, 0xF11C, 0xA1C5, 0xE4C7, 0x9A43, 0xDA29,
    0x93B5, 0xD0E5, 0x8DED, 0xC8B7, 0x88C6, 0xC16D, 0x8424, 0xBAE1
};

softfloat_approxRecipSqrt_1k1s

const uint16_t softfloat_approxRecipSqrt_1k1s[16]

extern

Definition at line 45 of file s_approxRecipSqrt_1Ks.c.

                                                    {
    0xA5A5, 0xEA42, 0x8C21, 0xC62D, 0x788F, 0xAA7F, 0x6928, 0x94B6,
    0x5CC7, 0x8335, 0x52A6, 0x74E2, 0x4A3E, 0x68FE, 0x432B, 0x5EFD
};

softfloat_countLeadingZeros8

const uint_least8_t softfloat_countLeadingZeros8[256]

extern

Definition at line 41 of file s_countLeadingZeros8.c.

                                                        {
    8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};