math32.h

FreeRTOS 是一个源码公开的免费的嵌入式实时操作系统

// SIZE

#pragma library 1
/*
uns16 operator* _mult8x8( uns8 arg1, uns8 arg2);
uns16 operator* _mult16x16( uns16 arg1, uns16 arg2);
uns24 operator* _multU16x8( uns16 arg1, uns8 arg2);
uns32 operator* _multU32x8( uns32 arg1, uns8 arg2);

uns32 operator* _multU32x16( uns32 arg1, uns16 arg2);
uns32 operator* _multU16x16( uns16 arg1, uns16 arg2);
int32 operator* _multS16x16( int16 arg1, int16 arg2);
uns32 operator* _multU32x16( uns32 arg1, uns16 arg2);
int32 operator* _multS32x16( int32 arg1, int16 arg2);
uns32 operator* _mult32x32( uns32 arg1, uns32 arg2);
uns16 operator/ _divU16_8( uns16 arg1, uns8 arg2);
uns24 operator/ _divU24_8( uns24 arg1, uns8 arg2);
uns32 operator/ _divU32_8( uns32 arg1, uns8 arg2);
uns16 operator/ _divU16_16( uns16 arg1, uns16 arg2);
uns32 operator/ _divU32_16( uns32 arg1, uns16 arg2);
uns32 operator/ _divU32_32( uns32 arg1, uns32 arg2);
int16 operator/ _divS16_8( int16 arg1, int8 arg2);
int24 operator/ _divS24_8( int24 arg1, int8 arg2);
int32 operator/ _divS32_8( int32 arg1, int8 arg2);
int16 operator/ _divS16_16( int16 arg1, int16 arg2);
int32 operator/ _divS32_16( int32 arg1, int16 arg2);
int32 operator/ _divS32_32( int32 arg1, int32 arg2);
uns8 operator% _remU16_8( uns16 arg1, uns8 arg2);
uns8 operator% _remU32_8( uns32 arg1, uns8 arg2);
uns16 operator% _remU16_16( uns16 arg1, uns16 arg2);
uns16 operator% _remU32_16( uns32 arg1, uns16 arg2);
uns32 operator% _remU32_32( uns32 arg1, uns32 arg2);
int8 operator% _remS16_8( int16 arg1, int8 arg2);
int8 operator% _remS32_8( int32 arg1, int8 arg2);
int16 operator% _remS16_16( int16 arg1, int16 arg2);
int16 operator% _remS32_16( int32 arg1, int16 arg2);
int32 operator% _remS32_32( int32 arg1, int32 arg2);
*/

// DEFINABLE SYMBOLS (in the application code):
//#define INT_OPTIM_SPEED  // optimize for SPEED: default
//#define INT_OPTIM_SIZE   // optimize for SIZE

#if __CoreSet__ < 1200  ||  __CoreSet__ >= 2100
 #error math24.h does not support the selected device
#endif

#if __CoreSet__ < 1600
 #define genAdd(r,a) W=a; btsc(Carry); W=incsz(a); r+=W;
 #define genSub(r,a) W=a; btss(Carry); W=incsz(a); r-=W;
 #define genAddW(r,a) W=a; btsc(Carry); W=incsz(a); W=r+W;
 #define genSubW(r,a) W=a; btss(Carry); W=incsz(a); W=r-W;
#else
 #define genAdd(r,a) W=a; r=addWFC(r);
 #define genSub(r,a) W=a; r=subWFB(r);
 #define genAddW(r,a) W=a; W=addWFC(r);
 #define genSubW(r,a) W=a; W=subWFB(r);
#endif

#if __CoreSet__ == 1700 || __CoreSet__ == 1800
 #define hw_mult8x8(a,b)  { W = a; multiply(b); }
 #define loRES PRODL
 #define hiRES PRODH
#endif

#if __CoreSet__ == 2000
 #define hw_mult8x8(a,b)  { W = a; multiply(b); }
 #define loRES W
 #define hiRES MULH
#endif


#ifdef hw_mult8x8

inline int16 operator*( int8 arg1, int8 arg2);
inline uns16 operator*( uns8 arg1, uns8 arg2);

inline int16 operator*( int8 arg1, int16 arg2);
inline uns16 operator*( uns8 arg1, uns16 arg2);
inline int16 operator*( int16 arg1, int8 arg2);
inline uns16 operator*( uns16 arg1, uns8 arg2);

inline int16 operator*( int16 arg1, int16 arg2);
inline uns16 operator*( uns16 arg1, uns16 arg2);

inline int32 operator*( int8 arg1, int24 arg2);
inline uns32 operator*( uns8 arg1, uns24 arg2);

inline int32 operator*( int24 arg1, int8 arg2);
inline uns32 operator*( uns24 arg1, uns8 arg2);

inline int32 operator*( int8 arg1, int32 arg2);
inline uns32 operator*( uns8 arg1, uns32 arg2);

inline int32 operator*( int32 arg1, int8 arg2);
inline uns32 operator*( uns32 arg1, uns8 arg2);


#else


int8 operator*( int8 arg1, int8 arg2)  @

uns16 operator* _mult8x8( uns8 arg1, uns8 arg2)
{
    uns16 rval;
    char counter = sizeof(arg2)*8;
    rval.high8 = 0;
    W = arg1;
    do  {
        arg2 = rr( arg2);
        if (Carry)
            rval.high8 += W;
        rval = rr( rval);
        counter = decsz(counter);
    } while (1);
    return rval;
}


int16 operator*( int16 arg1, int16 arg2) @

uns16 operator* _mult16x16( uns16 arg1, uns16 arg2)
{
    uns16 rval;
    char counter = sizeof(arg1)*8;
    do  {
        Carry = 0;
        rval = rl( rval);
        arg1 = rl( arg1);
        if (Carry)
            rval += arg2;
        counter = decsz(counter);
    } while (1);
    return rval;
}



uns24 operator*( uns8 arg1, uns16 arg2) exchangeArgs @

uns24 operator* _multU16x8( uns16 arg1, uns8 arg2)
{
    uns24 rval;
    rval.high8 = 0;
    char counter = sizeof(arg1)*8;
    W = arg2;
    do  {
        arg1 = rr( arg1);
        if (Carry)
            rval.high8 += W;
        rval = rr(rval);
        counter = decsz(counter);
    } while (1);
    return rval;
}


uns32 operator*( uns8 arg1, uns32 arg2) exchangeArgs @

uns32 operator* _multU32x8( uns32 arg1, uns8 arg2)
{
    uns8 rvalH = 0;
    char counter = 1+sizeof(arg1)*8;
    W = arg2;
    goto ENTRY;
    do  {
        if (Carry)
            rvalH += W;
        rvalH = rr( rvalH);
      ENTRY:
        arg1 = rr( arg1);
        counter = decsz(counter);
    } while (1);
    return arg1;
}

#endif


uns32 operator* _multU16x16( uns16 arg1, uns16 arg2)
{
    uns32 rval;

   #if defined hw_mult8x8 && !defined INT_OPTIM_SIZE

    hw_mult8x8( arg1.low8, arg2.low8);   // p1
    rval.low8 = loRES;
    rval.midL8 = hiRES;

    hw_mult8x8( arg1.high8, arg2.high8);  // p3
    rval.midH8 = loRES;
    rval.high8 = hiRES;

    hw_mult8x8( arg1.high8, arg2.low8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.low8, arg2.high8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

   #else

    char counter = sizeof(arg1)*8;
    rval.high16 = 0;
    do  {
        arg1 = rr( arg1);
        if (Carry)  {
            rval.midH8 += arg2.low8;
            genAdd( rval.high8, arg2.high8);
        }
        rval = rr( rval);
        counter = decsz(counter);
    } while (1);

   #endif

    return rval;
}


int32 operator* _multS16x16( int16 arg1, int16 arg2)
{
    int32 rval;

   #if defined hw_mult8x8 && !defined INT_OPTIM_SIZE

    hw_mult8x8( arg1.low8, arg2.low8);   // p1
    rval.low8 = loRES;
    rval.midL8 = hiRES;

    hw_mult8x8( arg1.high8, arg2.high8);  // p3
    rval.midH8 = loRES;
    rval.high8 = hiRES;

    hw_mult8x8( arg1.high8, arg2.low8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.low8, arg2.high8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

   #else

    char counter = sizeof(arg1)*8;
    int16 tmpArg1 = arg1;
    rval.high16 = 0;
    do  {
        tmpArg1 = rr( tmpArg1);
        if (Carry)  {
            rval.midH8 += arg2.low8;
            genAdd( rval.high8, arg2.high8);
        }
        rval = rr( rval);
        counter = decsz(counter);
    } while (1);

   #endif

    if (arg1 < 0)  {
        rval.midH8 -= arg2.low8;
        genSub(rval.high8, arg2.high8);
    }

    if (arg2 < 0)  {
        rval.midH8 -= arg1.low8;
        genSub(rval.high8, arg1.high8);
    }

    return rval;
}


uns32 operator*( uns16 arg1, uns32 arg2) exchangeArgs @

uns32 operator* _multU32x16( uns32 arg1, uns16 arg2)
{
    uns32 rval;

   #if defined hw_mult8x8 && !defined INT_OPTIM_SIZE

    hw_mult8x8( arg1.low8, arg2.low8);   // p1
    rval.low8 = loRES;
    rval.midL8 = hiRES;

    hw_mult8x8( arg1.midL8, arg2.high8);  // p3
    rval.midH8 = loRES;
    rval.high8 = hiRES;

    hw_mult8x8( arg1.midL8, arg2.low8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.low8, arg2.high8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.midH8, arg2.low8);  // p3
    rval.midH8 += loRES;
    genAdd( rval.high8, hiRES);

    hw_mult8x8( arg1.high8, arg2.low8);  // p4
    rval.high8 += loRES;

    hw_mult8x8( arg1.midH8, arg2.high8);  // p4
    rval.high8 += loRES;

   #else

    char counter = sizeof(arg2)*8;
    rval.low16 = 0;
    do  {
        Carry = 0;
        rval = rl( rval);
        arg2 = rl( arg2);
        if (Carry)  {
            rval.low8 += arg1.low8;
            genAdd( rval.midL8, arg1.midL8);
            genAdd( rval.midH8, arg1.midH8);
            genAdd( rval.high8, arg1.high8);
        }
        counter = decsz(counter);
    } while (1);

   #endif

    return rval;
}


int32 operator*( int16 arg1, int32 arg2) exchangeArgs @

int32 operator* _multS32x16( int32 arg1, int16 arg2)
{
    int32 rval;

   #if defined hw_mult8x8 && !defined INT_OPTIM_SIZE

    hw_mult8x8( arg1.low8, arg2.low8);   // p1
    rval.low8 = loRES;
    rval.midL8 = hiRES;

    hw_mult8x8( arg1.midL8, arg2.high8);  // p3
    rval.midH8 = loRES;
    rval.high8 = hiRES;

    hw_mult8x8( arg1.midL8, arg2.low8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.low8, arg2.high8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.midH8, arg2.low8);  // p3
    rval.midH8 += loRES;
    genAdd( rval.high8, hiRES);

    hw_mult8x8( arg1.high8, arg2.low8);  // p4
    rval.high8 += loRES;

    hw_mult8x8( arg1.midH8, arg2.high8);  // p4
    rval.high8 += loRES;

    if (arg2 < 0)  {
        rval.midH8 -= arg1.low8;
        genSub(rval.high8, arg1.midL8);
    }

   #else

    char counter = sizeof(arg2)*8;
    int8 sign = arg2.high8;
    rval.low16 = 0;
    do  {
        Carry = 0;
        rval = rl( rval);
        arg2 = rl( arg2);
        if (Carry)  {
            rval.low8 += arg1.low8;
            genAdd( rval.midL8, arg1.midL8);
            genAdd( rval.midH8, arg1.midH8);
            genAdd( rval.high8, arg1.high8);
        }
        counter = decsz(counter);
    } while (1);

    if (sign < 0)  {
        rval.midH8 -= arg1.low8;
        genSub(rval.high8, arg1.midL8);
    }

   #endif

    return rval;
}


int32 operator*( int32 arg1, int32 arg2) @

uns32 operator* _mult32x32( uns32 arg1, uns32 arg2)
{
    uns32 rval;

   #if defined hw_mult8x8 && !defined INT_OPTIM_SIZE

    hw_mult8x8( arg1.low8, arg2.low8);   // p1
    rval.low8 = loRES;
    rval.midL8 = hiRES;

    hw_mult8x8( arg1.midL8, arg2.midL8);  // p3
    rval.midH8 = loRES;
    rval.high8 = hiRES;

    hw_mult8x8( arg1.midL8, arg2.low8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.low8, arg2.midL8);  // p2
    rval.midL8 += loRES;
    genAdd( rval.midH8, hiRES);
    genAdd( rval.high8, 0);

    hw_mult8x8( arg1.midH8, arg2.low8);  // p3
    rval.midH8 += loRES;
    genAdd( rval.high8, hiRES);

    hw_mult8x8( arg1.low8, arg2.midH8);  // p3
    rval.midH8 += loRES;
    genAdd( rval.high8, hiRES);

    hw_mult8x8( arg1.high8, arg2.low8);  // p4
    rval.high8 += loRES;

    hw_mult8x8( arg1.midH8, arg2.midL8);  // p4
    rval.high8 += loRES;

    hw_mult8x8( arg1.midL8, arg2.midH8);  // p4
    rval.high8 += loRES;

    hw_mult8x8( arg1.low8, arg2.high8);  // p4
    rval.high8 += loRES;

   #else

    char counter = sizeof(arg1)*8;
    do  {
        Carry = 0;
        rval = rl( rval);
        arg1 = rl( arg1);
        if (Carry)  {
            rval.low8 += arg2.low8;
            genAdd( rval.midL8, arg2.midL8);
            genAdd( rval.midH8, arg2.midH8);
            genAdd( rval.high8, arg2.high8);
        }
        counter = decsz(counter);
    } while (1);

   #endif

    return rval;
}





uns16 operator/ _divU16_8( uns16 arg1, uns8 arg2)
{
    uns8 rm = 0;
    char counter = sizeof(arg1)*8+1;
    goto ENTRY;
    do  {
        rm = rl( rm);
        uns8 tmp = rl( tmp);
        W = rm - arg2;
        if (tmp&1)
            Carry = 1;
        if (Carry)
            rm = W;
       ENTRY:
        arg1 = rl( arg1);
        counter = decsz(counter);
    } while (1);
    return arg1;
}


uns24 operator/ _divU24_8( uns24 arg1, uns8 arg2)
{
    uns8 rm = 0;
    char counter = sizeof(arg1)*8+1;
    goto ENTRY;
    do  {
        rm = rl( rm);
        uns8 tmp = rl( tmp);
        W = rm - arg2;
        if (tmp&1)
            Carry = 1;
        if (Carry)
            rm = W;
       ENTRY:
        arg1 = rl( arg1);
        counter = decsz(counter);
    } while (1);
    return arg1;
}


uns32 operator/ _divU32_8( uns32 arg1, uns8 arg2)
{
    uns8 rm = 0;
    char counter = sizeof(arg1)*8+1;
    goto ENTRY;
    do  {
        rm = rl( rm);
        uns8 tmp = rl( tmp);
        W = rm - arg2;