# HG changeset patch # User Mychaela Falconia # Date 1718758286 0 # Node ID 66fb1fd032e6e0b2a3e8aa6c6bd12d0d6c88e0e9 # Parent 446a4a2955ba00c287af05f50db52510c4d4ccea libgsmhr1/mathhalf.[ch]: import original diff -r 446a4a2955ba -r 66fb1fd032e6 libgsmhr1/mathhalf.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libgsmhr1/mathhalf.c Wed Jun 19 00:51:26 2024 +0000 @@ -0,0 +1,1953 @@ +/*************************************************************************** + * + * File Name: mathhalf.c + * + * Purpose: Contains functions which implement the primitive + * arithmetic operations. + * + * The functions in this file are listed below. Some of them are + * defined in terms of other basic operations. One of the + * routines, saturate() is static. This is not a basic + * operation, and is not referenced outside the scope of this + * file. + * + * + * abs_s() + * add() + * divide_s() + * extract_h() + * extract_l() + * L_abs() + * L_add() + * L_deposit_h() + * L_deposit_l() + * L_mac() + * L_msu() + * L_mult() + * L_negate() + * L_shift_r() + * L_shl() + * L_shr() + * L_sub() + * mac_r() + * msu_r() + * mult() + * mult_r() + * negate() + * norm_l() + * norm_s() + * round() + * saturate() + * shift_r() + * shl() + * shr() + * sub() + * + **************************************************************************/ + +/*_________________________________________________________________________ + | | + | Include Files | + |_________________________________________________________________________| +*/ + +#include "typedefs.h" +#include "mathhalf.h" + +/*************************************************************************** + * + * FUNCTION NAME: saturate + * + * PURPOSE: + * + * Limit the 32 bit input to the range of a 16 bit word. + * + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * KEYWORDS: saturation, limiting, limit, saturate, 16 bits + * + *************************************************************************/ + +static Shortword saturate(Longword L_var1) +{ + Shortword swOut; + + if (L_var1 > SW_MAX) + { + swOut = SW_MAX; + } + else if (L_var1 < SW_MIN) + { + swOut = SW_MIN; + } + else + swOut = (Shortword) L_var1; /* automatic type conversion */ + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: abs_s + * + * PURPOSE: + * + * Take the absolute value of the 16 bit input. An input of + * -0x8000 results in a return value of 0x7fff. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0x0000 0000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Take the absolute value of the 16 bit input. An input of + * -0x8000 results in a return value of 0x7fff. + * + * KEYWORDS: absolute value, abs + * + *************************************************************************/ + +Shortword abs_s(Shortword var1) +{ + Shortword swOut; + + if (var1 == SW_MIN) + { + swOut = SW_MAX; + } + else + { + if (var1 < 0) + swOut = -var1; + else + swOut = var1; + } + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: add + * + * PURPOSE: + * + * Perform the addition of the two 16 bit input variable with + * saturation. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Perform the addition of the two 16 bit input variable with + * saturation. + * + * swOut = var1 + var2 + * + * swOut is set to 0x7fff if the operation results in an + * overflow. swOut is set to 0x8000 if the operation results + * in an underflow. + * + * KEYWORDS: add, addition + * + *************************************************************************/ + +Shortword add(Shortword var1, Shortword var2) +{ + Longword L_sum; + Shortword swOut; + + L_sum = (Longword) var1 + var2; + swOut = saturate(L_sum); + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: divide_s + * + * PURPOSE: + * + * Divide var1 by var2. Note that both must be positive, and + * var1 >= var2. The output is set to 0 if invalid input is + * provided. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * In the case where var1==var2 the function returns 0x7fff. The output + * is undefined for invalid inputs. This implementation returns zero + * and issues a warning via stdio if invalid input is presented. + * + * KEYWORDS: divide + * + *************************************************************************/ + +Shortword divide_s(Shortword var1, Shortword var2) +{ + Longword L_div; + Shortword swOut; + + if (var1 < 0 || var2 < 0 || var1 > var2) + { + /* undefined output for invalid input into divide_s */ + return (0); + } + + if (var1 == var2) + return (0x7fff); + + L_div = ((0x00008000L * (Longword) var1) / (Longword) var2); + swOut = saturate(L_div); + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: extract_h + * + * PURPOSE: + * + * Extract the 16 MS bits of a 32 bit Longword. Return the 16 bit + * number as a Shortword. This is used as a "truncation" of a fractional + * number. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * KEYWORDS: assign, truncate + * + *************************************************************************/ + +Shortword extract_h(Longword L_var1) +{ + Shortword var2; + + var2 = (Shortword) (0x0000ffffL & (L_var1 >> 16)); + return (var2); +} + +/*************************************************************************** + * + * FUNCTION NAME: extract_l + * + * PURPOSE: + * + * Extract the 16 LS bits of a 32 bit Longword. Return the 16 bit + * number as a Shortword. The upper portion of the input Longword + * has no impact whatsoever on the output. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * + * KEYWORDS: extract, assign + * + *************************************************************************/ + +Shortword extract_l(Longword L_var1) +{ + Shortword var2; + + var2 = (Shortword) (0x0000ffffL & L_var1); + return (var2); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_abs + * + * PURPOSE: + * + * Take the absolute value of the 32 bit input. An input of + * -0x8000 0000 results in a return value of 0x7fff ffff. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * + * + * KEYWORDS: absolute value, abs + * + *************************************************************************/ +Longword L_abs(Longword L_var1) +{ + Longword L_Out; + + if (L_var1 == LW_MIN) + { + L_Out = LW_MAX; + } + else + { + if (L_var1 < 0) + L_Out = -L_var1; + else + L_Out = L_var1; + } + return (L_Out); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_add + * + * PURPOSE: + * + * Perform the addition of the two 32 bit input variables with + * saturation. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * L_var2 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var2 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * IMPLEMENTATION: + * + * Perform the addition of the two 32 bit input variables with + * saturation. + * + * L_Out = L_var1 + L_var2 + * + * L_Out is set to 0x7fff ffff if the operation results in an + * overflow. L_Out is set to 0x8000 0000 if the operation + * results in an underflow. + * + * KEYWORDS: add, addition + * + *************************************************************************/ +Longword L_add(Longword L_var1, Longword L_var2) +{ + + Longword L_Sum, + L_SumLow, + L_SumHigh; + + L_Sum = L_var1 + L_var2; + + if ((L_var1 > 0 && L_var2 > 0) || (L_var1 < 0 && L_var2 < 0)) + { + + /* an overflow is possible */ + + L_SumLow = (L_var1 & 0xffff) + (L_var2 & 0xffff); + L_SumHigh = ((L_var1 >> 16) & 0xffff) + ((L_var2 >> 16) & 0xffff); + if (L_SumLow & 0x10000) + { + /* carry into high word is set */ + L_SumHigh += 1; + } + + /* update sum only if there is an overflow or underflow */ + /*------------------------------------------------------*/ + + if ((0x10000 & L_SumHigh) && !(0x8000 & L_SumHigh)) + L_Sum = LW_MIN; /* underflow */ + else if (!(0x10000 & L_SumHigh) && (0x8000 & L_SumHigh)) + L_Sum = LW_MAX; /* overflow */ + } + + return (L_Sum); + +} + +/*************************************************************************** + * + * FUNCTION NAME: L_deposit_h + * + * PURPOSE: + * + * Put the 16 bit input into the 16 MSB's of the output Longword. The + * LS 16 bits are zeroed. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff 0000. + * + * + * KEYWORDS: deposit, assign, fractional assign + * + *************************************************************************/ + +Longword L_deposit_h(Shortword var1) +{ + Longword L_var2; + + L_var2 = (Longword) var1 << 16; + return (L_var2); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_deposit_l + * + * PURPOSE: + * + * Put the 16 bit input into the 16 LSB's of the output Longword with + * sign extension i.e. the top 16 bits are set to either 0 or 0xffff. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0xffff 8000 <= L_var1 <= 0x0000 7fff. + * + * KEYWORDS: deposit, assign + * + *************************************************************************/ + +Longword L_deposit_l(Shortword var1) +{ + Longword L_Out; + + L_Out = var1; + return (L_Out); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_mac + * + * PURPOSE: + * + * Multiply accumulate. Fractionally multiply two 16 bit + * numbers together with saturation. Add that result to the + * 32 bit input with saturation. Return the 32 bit result. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * L_var3 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var2 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * IMPLEMENTATION: + * + * Fractionally multiply two 16 bit numbers together with + * saturation. The only numbers which will cause saturation on + * the multiply are 0x8000 * 0x8000. + * + * Add that result to the 32 bit input with saturation. + * Return the 32 bit result. + * + * Please note that this is not a true multiply accumulate as + * most processors would implement it. The 0x8000*0x8000 + * causes and overflow for this instruction. On most + * processors this would cause an overflow only if the 32 bit + * input added to it were positive or zero. + * + * KEYWORDS: mac, multiply accumulate + * + *************************************************************************/ + +Longword L_mac(Longword L_var3, Shortword var1, Shortword var2) +{ + return (L_add(L_var3, L_mult(var1, var2))); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_msu + * + * PURPOSE: + * + * Multiply and subtract. Fractionally multiply two 16 bit + * numbers together with saturation. Subtract that result from + * the 32 bit input with saturation. Return the 32 bit result. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * L_var3 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var2 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * IMPLEMENTATION: + * + * Fractionally multiply two 16 bit numbers together with + * saturation. The only numbers which will cause saturation on + * the multiply are 0x8000 * 0x8000. + * + * Subtract that result from the 32 bit input with saturation. + * Return the 32 bit result. + * + * Please note that this is not a true multiply accumulate as + * most processors would implement it. The 0x8000*0x8000 + * causes and overflow for this instruction. On most + * processors this would cause an overflow only if the 32 bit + * input added to it were negative or zero. + * + * KEYWORDS: mac, multiply accumulate, msu + * + *************************************************************************/ + +Longword L_msu(Longword L_var3, Shortword var1, Shortword var2) +{ + return (L_sub(L_var3, L_mult(var1, var2))); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_mult + * + * PURPOSE: + * + * Perform a fractional multipy of the two 16 bit input numbers + * with saturation. Output a 32 bit number. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * IMPLEMENTATION: + * + * Multiply the two the two 16 bit input numbers. If the + * result is within this range, left shift the result by one + * and output the 32 bit number. The only possible overflow + * occurs when var1==var2==-0x8000. In this case output + * 0x7fff ffff. + * + * KEYWORDS: multiply, mult, mpy + * + *************************************************************************/ + +Longword L_mult(Shortword var1, Shortword var2) +{ + Longword L_product; + + if (var1 == SW_MIN && var2 == SW_MIN) + L_product = LW_MAX; /* overflow */ + else + { + L_product = (Longword) var1 *var2; /* integer multiply */ + + L_product = L_product << 1; + } + return (L_product); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_negate + * + * PURPOSE: + * + * Negate the 32 bit input. 0x8000 0000's negated value is + * 0x7fff ffff. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0001 <= L_var1 <= 0x7fff ffff. + * + * KEYWORDS: negate, negative + * + *************************************************************************/ + +Longword L_negate(Longword L_var1) +{ + Longword L_Out; + + if (L_var1 == LW_MIN) + L_Out = LW_MAX; + else + L_Out = -L_var1; + return (L_Out); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_shift_r + * + * PURPOSE: + * + * Shift and round. Perform a shift right. After shifting, use + * the last bit shifted out of the LSB to round the result up + * or down. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * + * IMPLEMENTATION: + * + * Shift and round. Perform a shift right. After shifting, use + * the last bit shifted out of the LSB to round the result up + * or down. This is just like shift_r above except that the + * input/output is 32 bits as opposed to 16. + * + * if var2 is positve perform a arithmetic left shift + * with saturation (see L_shl() above). + * + * If var2 is zero simply return L_var1. + * + * If var2 is negative perform a arithmetic right shift (L_shr) + * of L_var1 by (-var2)+1. Add the LS bit of the result to + * L_var1 shifted right (L_shr) by -var2. + * + * Note that there is no constraint on var2, so if var2 is + * -0xffff 8000 then -var2 is 0x0000 8000, not 0x0000 7fff. + * This is the reason the L_shl function is used. + * + * + * KEYWORDS: + * + *************************************************************************/ + +Longword L_shift_r(Longword L_var1, Shortword var2) +{ + Longword L_Out, + L_rnd; + + if (var2 < -31) + { + L_Out = 0; + } + else if (var2 < 0) + { + /* right shift */ + L_rnd = L_shl(L_var1, var2 + 1) & 0x1; + L_Out = L_add(L_shl(L_var1, var2), L_rnd); + } + else + L_Out = L_shl(L_var1, var2); + + return (L_Out); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_shl + * + * PURPOSE: + * + * Arithmetic shift left (or right). + * Arithmetically shift the input left by var2. If var2 is + * negative then an arithmetic shift right (L_shr) of L_var1 by + * -var2 is performed. + * + * INPUTS: + * + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * + * IMPLEMENTATION: + * + * Arithmetically shift the 32 bit input left by var2. This + * operation maintains the sign of the input number. If var2 is + * negative then an arithmetic shift right (L_shr) of L_var1 by + * -var2 is performed. See description of L_shr for details. + * + * Equivalent to the Full-Rate GSM ">> n" operation. Note that + * ANSI-C does not guarantee operation of the C ">>" or "<<" + * operator for negative numbers. + * + * KEYWORDS: shift, arithmetic shift left, + * + *************************************************************************/ + +Longword L_shl(Longword L_var1, Shortword var2) +{ + + Longword L_Mask, + L_Out; + int i, + iOverflow = 0; + + if (var2 == 0 || L_var1 == 0) + { + L_Out = L_var1; + } + else if (var2 < 0) + { + if (var2 <= -31) + { + if (L_var1 > 0) + L_Out = 0; + else + L_Out = 0xffffffffL; + } + else + L_Out = L_shr(L_var1, -var2); + } + else + { + + if (var2 >= 31) + iOverflow = 1; + + else + { + + if (L_var1 < 0) + L_Mask = LW_SIGN; /* sign bit mask */ + else + L_Mask = 0x0; + L_Out = L_var1; + for (i = 0; i < var2 && !iOverflow; i++) + { + /* check the sign bit */ + L_Out = (L_Out & 0x7fffffffL) << 1; + if ((L_Mask ^ L_Out) & LW_SIGN) + iOverflow = 1; + } + } + + if (iOverflow) + { + /* saturate */ + if (L_var1 > 0) + L_Out = LW_MAX; + else + L_Out = LW_MIN; + } + } + + return (L_Out); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_shr + * + * PURPOSE: + * + * Arithmetic shift right (or left). + * Arithmetically shift the input right by var2. If var2 is + * negative then an arithmetic shift left (shl) of var1 by + * -var2 is performed. + * + * INPUTS: + * + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * + * IMPLEMENTATION: + * + * Arithmetically shift the input right by var2. This + * operation maintains the sign of the input number. If var2 is + * negative then an arithmetic shift left (shl) of L_var1 by + * -var2 is performed. See description of L_shl for details. + * + * The input is a 32 bit number, as is the output. + * + * Equivalent to the Full-Rate GSM ">> n" operation. Note that + * ANSI-C does not guarantee operation of the C ">>" or "<<" + * operator for negative numbers. + * + * KEYWORDS: shift, arithmetic shift right, + * + *************************************************************************/ + +Longword L_shr(Longword L_var1, Shortword var2) +{ + + Longword L_Mask, + L_Out; + + if (var2 == 0 || L_var1 == 0) + { + L_Out = L_var1; + } + else if (var2 < 0) + { + /* perform a left shift */ + /*----------------------*/ + if (var2 <= -31) + { + /* saturate */ + if (L_var1 > 0) + L_Out = LW_MAX; + else + L_Out = LW_MIN; + } + else + L_Out = L_shl(L_var1, -var2); + } + else + { + + if (var2 >= 31) + { + if (L_var1 > 0) + L_Out = 0; + else + L_Out = 0xffffffffL; + } + else + { + L_Mask = 0; + + if (L_var1 < 0) + { + L_Mask = ~L_Mask << (32 - var2); + } + + L_var1 >>= var2; + L_Out = L_Mask | L_var1; + } + } + return (L_Out); +} + +/*************************************************************************** + * + * FUNCTION NAME: L_sub + * + * PURPOSE: + * + * Perform the subtraction of the two 32 bit input variables with + * saturation. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * L_var2 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var2 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * L_Out + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * IMPLEMENTATION: + * + * Perform the subtraction of the two 32 bit input variables with + * saturation. + * + * L_Out = L_var1 - L_var2 + * + * L_Out is set to 0x7fff ffff if the operation results in an + * overflow. L_Out is set to 0x8000 0000 if the operation + * results in an underflow. + * + * KEYWORDS: sub, subtraction + * + *************************************************************************/ +Longword L_sub(Longword L_var1, Longword L_var2) +{ + Longword L_Sum; + + /* check for overflow */ + if ((L_var1 > 0 && L_var2 < 0) || (L_var1 < 0 && L_var2 > 0)) + { + if (L_var2 == LW_MIN) + { + L_Sum = L_add(L_var1, LW_MAX); + L_Sum = L_add(L_Sum, 1); + } + else + L_Sum = L_add(L_var1, -L_var2); + } + else + { /* no overflow possible */ + L_Sum = L_var1 - L_var2; + } + return (L_Sum); +} + +/*************************************************************************** + * + * FUNCTION NAME:mac_r + * + * PURPOSE: + * + * Multiply accumulate and round. Fractionally multiply two 16 + * bit numbers together with saturation. Add that result to + * the 32 bit input with saturation. Finally round the result + * into a 16 bit number. + * + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * L_var3 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var2 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Fractionally multiply two 16 bit numbers together with + * saturation. The only numbers which will cause saturation on + * the multiply are 0x8000 * 0x8000. + * + * Add that result to the 32 bit input with saturation. + * Round the 32 bit result by adding 0x0000 8000 to the input. + * The result may overflow due to the add. If so, the result + * is saturated. The 32 bit rounded number is then shifted + * down 16 bits and returned as a Shortword. + * + * Please note that this is not a true multiply accumulate as + * most processors would implement it. The 0x8000*0x8000 + * causes and overflow for this instruction. On most + * processors this would cause an overflow only if the 32 bit + * input added to it were positive or zero. + * + * KEYWORDS: mac, multiply accumulate, macr + * + *************************************************************************/ + +Shortword mac_r(Longword L_var3, Shortword var1, Shortword var2) +{ + return (round(L_add(L_var3, L_mult(var1, var2)))); +} + +/*************************************************************************** + * + * FUNCTION NAME: msu_r + * + * PURPOSE: + * + * Multiply subtract and round. Fractionally multiply two 16 + * bit numbers together with saturation. Subtract that result from + * the 32 bit input with saturation. Finally round the result + * into a 16 bit number. + * + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * L_var3 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var2 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Fractionally multiply two 16 bit numbers together with + * saturation. The only numbers which will cause saturation on + * the multiply are 0x8000 * 0x8000. + * + * Subtract that result from the 32 bit input with saturation. + * Round the 32 bit result by adding 0x0000 8000 to the input. + * The result may overflow due to the add. If so, the result + * is saturated. The 32 bit rounded number is then shifted + * down 16 bits and returned as a Shortword. + * + * Please note that this is not a true multiply accumulate as + * most processors would implement it. The 0x8000*0x8000 + * causes and overflow for this instruction. On most + * processors this would cause an overflow only if the 32 bit + * input added to it were positive or zero. + * + * KEYWORDS: mac, multiply accumulate, macr + * + *************************************************************************/ + +Shortword msu_r(Longword L_var3, Shortword var1, Shortword var2) +{ + return (round(L_sub(L_var3, L_mult(var1, var2)))); +} + +/*************************************************************************** + * + * FUNCTION NAME: mult + * + * PURPOSE: + * + * Perform a fractional multipy of the two 16 bit input numbers + * with saturation and truncation. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Perform a fractional multipy of the two 16 bit input + * numbers. If var1 == var2 == -0x8000, output 0x7fff. + * Otherwise output var1*var2 >> 15. The output is a + * 16 bit number. + * + * KEYWORDS: mult, mulitply, mpy + * + *************************************************************************/ + +Shortword mult(Shortword var1, Shortword var2) +{ + Longword L_product; + Shortword swOut; + + L_product = L_mult(var1, var2); + swOut = extract_h(L_product); + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: mult_r + * + * PURPOSE: + * + * Perform a fractional multipy and round of the two 16 bit + * input numbers with saturation. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * This routine is defined as the concatenation of the multiply + * operation and the round operation. + * + * The fractional multiply (L_mult) produces a saturated 32 bit + * output. This is followed by a an add of 0x0000 8000 to the + * 32 bit result. The result may overflow due to the add. If + * so, the result is saturated. The 32 bit rounded number is + * then shifted down 16 bits and returned as a Shortword. + * + * + * KEYWORDS: multiply and round, round, mult_r, mpyr + * + *************************************************************************/ + + +Shortword mult_r(Shortword var1, Shortword var2) +{ + Shortword swOut; + + swOut = round(L_mult(var1, var2)); + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: negate + * + * PURPOSE: + * + * Negate the 16 bit input. 0x8000's negated value is 0x7fff. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8001 <= swOut <= 0x0000 7fff. + * + * KEYWORDS: negate, negative, invert + * + *************************************************************************/ + +Shortword negate(Shortword var1) +{ + Shortword swOut; + + if (var1 == SW_MIN) + swOut = SW_MAX; + else + swOut = -var1; + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: norm_l + * + * PURPOSE: + * + * Get normalize shift count: + * + * A 32 bit number is input (possiblly unnormalized). Output + * the positive (or zero) shift count required to normalize the + * input. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0 <= swOut <= 31 + * + * + * + * IMPLEMENTATION: + * + * Get normalize shift count: + * + * A 32 bit number is input (possiblly unnormalized). Output + * the positive (or zero) shift count required to normalize the + * input. + * + * If zero in input, return 0 as the shift count. + * + * For non-zero numbers, count the number of left shift + * required to get the number to fall into the range: + * + * 0x4000 0000 >= normlzd number >= 0x7fff ffff (positive number) + * or + * 0x8000 0000 <= normlzd number < 0xc000 0000 (negative number) + * + * Return the number of shifts. + * + * This instruction corresponds exactly to the Full-Rate "norm" + * instruction. + * + * KEYWORDS: norm, normalization + * + *************************************************************************/ + +Shortword norm_l(Longword L_var1) +{ + + Shortword swShiftCnt; + + if (L_var1 != 0) + { + if (!(L_var1 & LW_SIGN)) + { + + /* positive input */ + for (swShiftCnt = 0; !(L_var1 <= LW_MAX && L_var1 >= 0x40000000L); + swShiftCnt++) + { + L_var1 = L_var1 << 1; + } + + } + else + { + /* negative input */ + for (swShiftCnt = 0; + !(L_var1 >= LW_MIN && L_var1 < (Longword) 0xc0000000L); + swShiftCnt++) + { + L_var1 = L_var1 << 1; + } + } + } + else + { + swShiftCnt = 0; + } + return (swShiftCnt); +} + +/*************************************************************************** + * + * FUNCTION NAME: norm_s + * + * PURPOSE: + * + * Get normalize shift count: + * + * A 16 bit number is input (possiblly unnormalized). Output + * the positive (or zero) shift count required to normalize the + * input. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0 <= swOut <= 15 + * + * + * + * IMPLEMENTATION: + * + * Get normalize shift count: + * + * A 16 bit number is input (possiblly unnormalized). Output + * the positive (or zero) shift count required to normalize the + * input. + * + * If zero in input, return 0 as the shift count. + * + * For non-zero numbers, count the number of left shift + * required to get the number to fall into the range: + * + * 0x4000 >= normlzd number >= 0x7fff (positive number) + * or + * 0x8000 <= normlzd number < 0xc000 (negative number) + * + * Return the number of shifts. + * + * This instruction corresponds exactly to the Full-Rate "norm" + * instruction. + * + * KEYWORDS: norm, normalization + * + *************************************************************************/ + +Shortword norm_s(Shortword var1) +{ + + short swShiftCnt; + Longword L_var1; + + L_var1 = L_deposit_h(var1); + swShiftCnt = norm_l(L_var1); + return (swShiftCnt); +} + +/*************************************************************************** + * + * FUNCTION NAME: round + * + * PURPOSE: + * + * Round the 32 bit Longword into a 16 bit shortword with saturation. + * + * INPUTS: + * + * L_var1 + * 32 bit long signed integer (Longword) whose value + * falls in the range + * 0x8000 0000 <= L_var1 <= 0x7fff ffff. + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Perform a two's complement round on the input Longword with + * saturation. + * + * This is equivalent to adding 0x0000 8000 to the input. The + * result may overflow due to the add. If so, the result is + * saturated. The 32 bit rounded number is then shifted down + * 16 bits and returned as a Shortword. + * + * + * KEYWORDS: round + * + *************************************************************************/ + +Shortword round(Longword L_var1) +{ + Longword L_Prod; + + L_Prod = L_add(L_var1, 0x00008000L); /* round MSP */ + return (extract_h(L_Prod)); +} + +/*************************************************************************** + * + * FUNCTION NAME: shift_r + * + * PURPOSE: + * + * Shift and round. Perform a shift right. After shifting, use + * the last bit shifted out of the LSB to round the result up + * or down. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * + * IMPLEMENTATION: + * + * Shift and round. Perform a shift right. After shifting, use + * the last bit shifted out of the LSB to round the result up + * or down. + * + * If var2 is positive perform a arithmetic left shift + * with saturation (see shl() above). + * + * If var2 is zero simply return var1. + * + * If var2 is negative perform a arithmetic right shift (shr) + * of var1 by (-var2)+1. Add the LS bit of the result to var1 + * shifted right (shr) by -var2. + * + * Note that there is no constraint on var2, so if var2 is + * -0xffff 8000 then -var2 is 0x0000 8000, not 0x0000 7fff. + * This is the reason the shl function is used. + * + * + * KEYWORDS: + * + *************************************************************************/ + +Shortword shift_r(Shortword var1, Shortword var2) +{ + Shortword swOut, + swRnd; + + if (var2 >= 0) + swOut = shl(var1, var2); + else + { + + /* right shift */ + + if (var2 < -15) + { + + swOut = 0; + + } + else + { + + swRnd = shl(var1, var2 + 1) & 0x1; + swOut = add(shl(var1, var2), swRnd); + + } + } + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: shl + * + * PURPOSE: + * + * Arithmetically shift the input left by var2. + * + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * If Arithmetically shift the input left by var2. If var2 is + * negative then an arithmetic shift right (shr) of var1 by + * -var2 is performed. See description of shr for details. + * When an arithmetic shift left is performed the var2 LS bits + * are zero filled. + * + * The only exception is if the left shift causes an overflow + * or underflow. In this case the LS bits are not modified. + * The number returned is 0x8000 in the case of an underflow or + * 0x7fff in the case of an overflow. + * + * The shl is equivalent to the Full-Rate GSM "<< n" operation. + * Note that ANSI-C does not guarantee operation of the C ">>" + * or "<<" operator for negative numbers - it is not specified + * whether this shift is an arithmetic or logical shift. + * + * KEYWORDS: asl, arithmetic shift left, shift + * + *************************************************************************/ + +Shortword shl(Shortword var1, Shortword var2) +{ + Shortword swOut; + Longword L_Out; + + if (var2 == 0 || var1 == 0) + { + swOut = var1; + } + else if (var2 < 0) + { + + /* perform a right shift */ + /*-----------------------*/ + + if (var2 <= -15) + { + if (var1 < 0) + swOut = (Shortword) 0xffff; + else + swOut = 0x0; + } + else + swOut = shr(var1, -var2); + + } + else + { + /* var2 > 0 */ + if (var2 >= 15) + { + /* saturate */ + if (var1 > 0) + swOut = SW_MAX; + else + swOut = SW_MIN; + } + else + { + + L_Out = (Longword) var1 *(1 << var2); + + swOut = (Shortword) L_Out; /* copy low portion to swOut, overflow + * could have hpnd */ + if (swOut != L_Out) + { + /* overflow */ + if (var1 > 0) + swOut = SW_MAX; /* saturate */ + else + swOut = SW_MIN; /* saturate */ + } + } + } + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: shr + * + * PURPOSE: + * + * Arithmetic shift right (or left). + * Arithmetically shift the input right by var2. If var2 is + * negative then an arithmetic shift left (shl) of var1 by + * -var2 is performed. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Arithmetically shift the input right by var2. This + * operation maintains the sign of the input number. If var2 is + * negative then an arithmetic shift left (shl) of var1 by + * -var2 is performed. See description of shl for details. + * + * Equivalent to the Full-Rate GSM ">> n" operation. Note that + * ANSI-C does not guarantee operation of the C ">>" or "<<" + * operator for negative numbers. + * + * KEYWORDS: shift, arithmetic shift right, + * + *************************************************************************/ + +Shortword shr(Shortword var1, Shortword var2) +{ + + Shortword swMask, + swOut; + + if (var2 == 0 || var1 == 0) + swOut = var1; + + else if (var2 < 0) + { + /* perform an arithmetic left shift */ + /*----------------------------------*/ + if (var2 <= -15) + { + /* saturate */ + if (var1 > 0) + swOut = SW_MAX; + else + swOut = SW_MIN; + } + else + swOut = shl(var1, -var2); + } + + else + { + + /* positive shift count */ + /*----------------------*/ + + if (var2 >= 15) + { + if (var1 < 0) + swOut = (Shortword) 0xffff; + else + swOut = 0x0; + } + else + { + /* take care of sign extension */ + /*-----------------------------*/ + + swMask = 0; + if (var1 < 0) + { + swMask = ~swMask << (16 - var2); + } + + var1 >>= var2; + swOut = swMask | var1; + + } + } + return (swOut); +} + +/*************************************************************************** + * + * FUNCTION NAME: sub + * + * PURPOSE: + * + * Perform the subtraction of the two 16 bit input variable with + * saturation. + * + * INPUTS: + * + * var1 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff. + * var2 + * 16 bit short signed integer (Shortword) whose value + * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff. + * + * OUTPUTS: + * + * none + * + * RETURN VALUE: + * + * swOut + * 16 bit short signed integer (Shortword) whose value + * falls in the range + * 0xffff 8000 <= swOut <= 0x0000 7fff. + * + * IMPLEMENTATION: + * + * Perform the subtraction of the two 16 bit input variable with + * saturation. + * + * swOut = var1 - var2 + * + * swOut is set to 0x7fff if the operation results in an + * overflow. swOut is set to 0x8000 if the operation results + * in an underflow. + * + * KEYWORDS: sub, subtraction + * + *************************************************************************/ +Shortword sub(Shortword var1, Shortword var2) +{ + Longword L_diff; + Shortword swOut; + + L_diff = (Longword) var1 - var2; + swOut = saturate(L_diff); + + return (swOut); +} diff -r 446a4a2955ba -r 66fb1fd032e6 libgsmhr1/mathhalf.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libgsmhr1/mathhalf.h Wed Jun 19 00:51:26 2024 +0000 @@ -0,0 +1,97 @@ +#ifndef __MATHHALF +#define __MATHHALF + +#include "typedefs.h" + +/*_________________________________________________________________________ + | | + | Function Prototypes | + |_________________________________________________________________________| +*/ + +/* addition */ +/************/ + +Shortword add(Shortword var1, Shortword var2); /* 1 ops */ +Shortword sub(Shortword var1, Shortword var2); /* 1 ops */ +Longword L_add(Longword L_var1, Longword L_var2); /* 2 ops */ +Longword L_sub(Longword L_var1, Longword L_var2); /* 2 ops */ + +/* multiplication */ +/******************/ + +Shortword mult(Shortword var1, Shortword var2); /* 1 ops */ +Longword L_mult(Shortword var1, Shortword var2); /* 1 ops */ +Shortword mult_r(Shortword var1, Shortword var2); /* 2 ops */ + + +/* arithmetic shifts */ +/*********************/ + +Shortword shr(Shortword var1, Shortword var2); /* 1 ops */ +Shortword shl(Shortword var1, Shortword var2); /* 1 ops */ +Longword L_shr(Longword L_var1, Shortword var2); /* 2 ops */ +Longword L_shl(Longword L_var1, Shortword var2); /* 2 ops */ +Shortword shift_r(Shortword var, Shortword var2); /* 2 ops */ +Longword L_shift_r(Longword L_var, Shortword var2); /* 3 ops */ + +/* absolute value */ +/*******************/ + +Shortword abs_s(Shortword var1); /* 1 ops */ +Longword L_abs(Longword var1); /* 3 ops */ + + +/* multiply accumulate */ +/************************/ + +Longword L_mac(Longword L_var3, + Shortword var1, Shortword var2); /* 1 op */ +Shortword mac_r(Longword L_var3, + Shortword var1, Shortword var2); /* 2 op */ +Longword L_msu(Longword L_var3, + Shortword var1, Shortword var2); /* 1 op */ +Shortword msu_r(Longword L_var3, + Shortword var1, Shortword var2); /* 2 op */ + +/* negation */ +/*************/ + +Shortword negate(Shortword var1); /* 1 ops */ +Longword L_negate(Longword L_var1); /* 2 ops */ + + +/* Accumulator manipulation */ +/****************************/ + +Longword L_deposit_l(Shortword var1); /* 1 ops */ +Longword L_deposit_h(Shortword var1); /* 1 ops */ +Shortword extract_l(Longword L_var1); /* 1 ops */ +Shortword extract_h(Longword L_var1); /* 1 ops */ + +/* Round */ +/*********/ + +Shortword round(Longword L_var1); /* 1 ops */ + +/* Normalization */ +/*****************/ + +Shortword norm_l(Longword L_var1); /* 30 ops */ +Shortword norm_s(Shortword var1); /* 15 ops */ + +/* Division */ +/************/ +Shortword divide_s(Shortword var1, Shortword var2); /* 18 ops */ + +/* Non-saturating instructions */ +/*******************************/ +Longword L_add_c(Longword L_Var1, Longword L_Var2); /* 2 ops */ +Longword L_sub_c(Longword L_Var1, Longword L_Var2); /* 2 ops */ +Longword L_sat(Longword L_var1); /* 4 ops */ +Longword L_macNs(Longword L_var3, + Shortword var1, Shortword var2); /* 1 ops */ +Longword L_msuNs(Longword L_var3, + Shortword var1, Shortword var2); /* 1 ops */ + +#endif