0,0 → 1,1205 |
/* This is a software fixed-point library. |
Copyright (C) 2007-2015 Free Software Foundation, Inc. |
|
This file is part of GCC. |
|
GCC is free software; you can redistribute it and/or modify it under |
the terms of the GNU General Public License as published by the Free |
Software Foundation; either version 3, or (at your option) any later |
version. |
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
WARRANTY; without even the implied warranty of MERCHANTABILITY or |
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
for more details. |
|
Under Section 7 of GPL version 3, you are granted additional |
permissions described in the GCC Runtime Library Exception, version |
3.1, as published by the Free Software Foundation. |
|
You should have received a copy of the GNU General Public License and |
a copy of the GCC Runtime Library Exception along with this program; |
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
<http://www.gnu.org/licenses/>. */ |
|
/* This implements fixed-point arithmetic. |
|
Contributed by Chao-ying Fu <fu@mips.com>. */ |
|
/* To use this file, we need to define one of the following: |
QQ_MODE, UQQ_MODE, HQ_MODE, UHQ_MODE, SQ_MODE, USQ_MODE, DQ_MODE, UDQ_MODE, |
TQ_MODE, UTQ_MODE, HA_MODE, UHA_MODE, SA_MODE, USA_MODE, DA_MODE, UDA_MODE, |
TA_MODE, UTA_MODE. |
Then, all operators for this machine mode will be created. |
|
Or, we need to define FROM_* TO_* for conversions from one mode to another |
mode. The mode could be one of the following: |
Fract: QQ, UQQ, HQ, UHQ, SQ, USQ, DQ, UDQ, TQ, UTQ |
Accum: HA, UHA, SA, USA, DA, UDA, TA, UTA |
Signed integer: QI, HI, SI, DI, TI |
Unsigned integer: UQI, UHI, USI, UDI, UTI |
Floating-point: SF, DF |
Ex: If we define FROM_QQ and TO_SI, the conversion from QQ to SI is |
generated. */ |
|
#include "tconfig.h" |
#include "tsystem.h" |
#include "coretypes.h" |
#include "tm.h" |
#include "libgcc_tm.h" |
|
#ifndef MIN_UNITS_PER_WORD |
#define MIN_UNITS_PER_WORD UNITS_PER_WORD |
#endif |
|
#include "fixed-bit.h" |
|
#if defined(FIXED_ADD) && defined(L_add) |
FIXED_C_TYPE |
FIXED_ADD (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
z = x + y; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_ADD */ |
|
#if defined(FIXED_SSADD) && defined(L_ssadd) |
FIXED_C_TYPE |
FIXED_SSADD (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
z = x + (UINT_C_TYPE) y; |
if ((((x ^ y) >> I_F_BITS) & 1) == 0) |
{ |
if (((z ^ x) >> I_F_BITS) & 1) |
{ |
z = ((UINT_C_TYPE) 1) << I_F_BITS; |
if (x >= 0) |
z -= (UINT_C_TYPE) 1; |
} |
} |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_SSADD */ |
|
#if defined(FIXED_USADD) && defined(L_usadd) |
FIXED_C_TYPE |
FIXED_USADD (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
z = x + y; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
if (z < x || z < y) /* max */ |
{ |
z = -1; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
} |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_USADD */ |
|
#if defined(FIXED_SUB) && defined(L_sub) |
FIXED_C_TYPE |
FIXED_SUB (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
z = x - y; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_SUB */ |
|
#if defined(FIXED_SSSUB) && defined(L_sssub) |
FIXED_C_TYPE |
FIXED_SSSUB (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
z = x - (UINT_C_TYPE) y; |
if (((x ^ y) >> I_F_BITS) & 1) |
{ |
if (((z ^ x) >> I_F_BITS) & 1) |
{ |
z = ((UINT_C_TYPE) 1) << I_F_BITS; |
if (x >= 0) |
z -= (UINT_C_TYPE) 1; |
} |
} |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_SSSUB */ |
|
#if defined(FIXED_USSUB) && defined(L_ussub) |
FIXED_C_TYPE |
FIXED_USSUB (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
z = x - y; |
if (x < y) |
z = 0; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_USSUB */ |
|
#if defined(FIXED_SATURATE1) && defined(L_saturate1) |
void |
FIXED_SATURATE1 (DINT_C_TYPE *a) |
{ |
DINT_C_TYPE max, min; |
max = (DINT_C_TYPE)1 << I_F_BITS; |
max = max - 1; |
#if MODE_UNSIGNED == 0 |
min = (DINT_C_TYPE)1 << (2 * FIXED_WIDTH - 1); |
min = min >> (2 * FIXED_WIDTH - 1 - I_F_BITS); |
#else |
min = 0; |
#endif |
if (*a > max) |
*a = max; |
else if (*a < min) |
*a = min; |
} |
#endif /* FIXED_SATURATE1 */ |
|
#if defined(FIXED_SATURATE2) && defined(L_saturate2) |
void |
FIXED_SATURATE2 (INT_C_TYPE *high, INT_C_TYPE *low) |
{ |
INT_C_TYPE r_max, s_max, r_min, s_min; |
r_max = 0; |
#if (MODE_UNSIGNED == 0) || HAVE_PADDING_BITS |
s_max = (INT_C_TYPE)1 << I_F_BITS; |
s_max = s_max - 1; |
#else |
s_max = -1; |
#endif |
#if MODE_UNSIGNED == 0 |
r_min = -1; |
s_min = (INT_C_TYPE)1 << (FIXED_WIDTH - 1); |
s_min = s_min >> (FIXED_WIDTH - 1 - I_F_BITS); |
#else |
r_min = 0; |
s_min = 0; |
#endif |
|
if (*high > r_max |
|| (*high == r_max && (UINT_C_TYPE)(*low) > (UINT_C_TYPE)s_max)) |
{ |
*high = r_max; |
*low = s_max; |
} |
else if (*high < r_min || |
(*high == r_min && (UINT_C_TYPE)(*low) < (UINT_C_TYPE)s_min)) |
{ |
*high = r_min; |
*low = s_min; |
} |
} |
#endif /* FIXED_SATURATE2 */ |
|
#if defined(FIXED_MULHELPER) && defined(L_mulhelper) |
FIXED_C_TYPE |
FIXED_MULHELPER (FIXED_C_TYPE a, FIXED_C_TYPE b, word_type satp) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y; |
|
#if defined (DINT_C_TYPE) |
INT_C_TYPE z; |
DINT_C_TYPE dx, dy, dz; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
dx = (DINT_C_TYPE) x; |
dy = (DINT_C_TYPE) y; |
dz = dx * dy; |
/* Round the result by adding (1 << (FBITS -1)). */ |
dz += ((DINT_C_TYPE) 1 << (FBITS - 1)); |
dz = dz >> FBITS; |
if (satp) |
FIXED_SATURATE1 (&dz); |
|
z = (INT_C_TYPE) dz; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
|
#else /* No DINT_C_TYPE */ |
/* The result of multiplication expands to two INT_C_TYPE. */ |
INTunion aa, bb; |
INTunion a_high, a_low, b_high, b_low; |
INTunion high_high, high_low, low_high, low_low; |
INTunion r, s, temp1, temp2; |
INT_C_TYPE carry = 0; |
INT_C_TYPE z; |
|
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
|
/* Decompose a and b. */ |
aa.ll = x; |
bb.ll = y; |
|
a_high.s.low = aa.s.high; |
a_high.s.high = 0; |
a_low.s.low = aa.s.low; |
a_low.s.high = 0; |
b_high.s.low = bb.s.high; |
b_high.s.high = 0; |
b_low.s.low = bb.s.low; |
b_low.s.high = 0; |
|
/* Perform four multiplications. */ |
low_low.ll = a_low.ll * b_low.ll; |
low_high.ll = a_low.ll * b_high.ll; |
high_low.ll = a_high.ll * b_low.ll; |
high_high.ll = a_high.ll * b_high.ll; |
|
/* Accumulate four results to {r, s}. */ |
temp1.s.high = high_low.s.low; |
temp1.s.low = 0; |
s.ll = low_low.ll + temp1.ll; |
if ((UINT_C_TYPE) s.ll < (UINT_C_TYPE) low_low.ll |
|| (UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp1.ll) |
carry ++; /* Carry. */ |
temp1.ll = s.ll; |
temp2.s.high = low_high.s.low; |
temp2.s.low = 0; |
s.ll = temp1.ll + temp2.ll; |
if ((UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp1.ll |
|| (UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp2.ll) |
carry ++; /* Carry. */ |
|
temp1.s.low = high_low.s.high; |
temp1.s.high = 0; |
r.ll = high_high.ll + temp1.ll; |
temp1.s.low = low_high.s.high; |
temp1.s.high = 0; |
r.ll = r.ll + temp1.ll + carry; |
|
#if MODE_UNSIGNED == 0 |
/* For signed types, we need to add neg(y) to r, if x < 0. */ |
if (x < 0) |
r.ll = r.ll - y; |
/* We need to add neg(x) to r, if y < 0. */ |
if (y < 0) |
r.ll = r.ll - x; |
#endif |
|
/* Round the result by adding (1 << (FBITS -1)). */ |
temp1.ll = s.ll; |
s.ll += ((INT_C_TYPE) 1 << (FBITS -1)); |
if ((UINT_C_TYPE) s.ll < (UINT_C_TYPE) temp1.ll |
|| (UINT_C_TYPE) s.ll < (UINT_C_TYPE) ((INT_C_TYPE) 1 << (FBITS -1))) |
r.ll += 1; |
|
/* Shift right the result by FBITS. */ |
#if FBITS == FIXED_WIDTH |
/* This happens only for unsigned types without any padding bits. |
So, it is safe to set r.ll to 0 as it is logically shifted right. */ |
s.ll = r.ll; |
r.ll = 0; |
#else |
s.ll = ((UINT_C_TYPE)s.ll) >> FBITS; |
temp1.ll = r.ll << (FIXED_WIDTH - FBITS); |
s.ll = s.ll | temp1.ll; |
r.ll = r.ll >> FBITS; |
#endif |
|
if (satp) |
FIXED_SATURATE2 (&r.ll, &s.ll); |
|
z = (INT_C_TYPE) s.ll; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
#endif |
} |
#endif /* FIXED_MULHELPER */ |
|
#if defined(FIXED_MUL) && defined(L_mul) |
FIXED_C_TYPE |
FIXED_MUL (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_MULHELPER (a, b, 0); |
} |
#endif /* FIXED_MUL */ |
|
#if defined(FIXED_SSMUL) && defined(L_ssmul) |
FIXED_C_TYPE |
FIXED_SSMUL (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_MULHELPER (a, b, 1); |
} |
#endif /* FIXED_SSMUL */ |
|
#if defined(FIXED_USMUL) && defined(L_usmul) |
FIXED_C_TYPE |
FIXED_USMUL (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_MULHELPER (a, b, 1); |
} |
#endif /* FIXED_USMUL */ |
|
#if defined(FIXED_DIVHELPER) && defined(L_divhelper) |
FIXED_C_TYPE |
FIXED_DIVHELPER (FIXED_C_TYPE a, FIXED_C_TYPE b, word_type satp) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y; |
INT_C_TYPE z; |
|
#if defined (DINT_C_TYPE) |
DINT_C_TYPE dx, dy, dz; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
dx = (DINT_C_TYPE) x; |
dy = (DINT_C_TYPE) y; |
dx = dx << FBITS; |
dz = dx / dy; |
if (satp) |
FIXED_SATURATE1 (&dz); |
z = (INT_C_TYPE) dz; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
|
#else /* No DINT_C_TYPE */ |
INT_C_TYPE pos_a, pos_b, r, s; |
INT_C_TYPE quo_r, quo_s, mod, temp; |
word_type i; |
#if MODE_UNSIGNED == 0 |
word_type num_of_neg = 0; |
#endif |
|
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
pos_a = x; |
pos_b = y; |
|
#if MODE_UNSIGNED == 0 |
/* If a < 0, negate a. */ |
if (pos_a < 0) |
{ |
pos_a = -pos_a; |
num_of_neg ++; |
} |
/* If b < 0, negate b. */ |
if (pos_b < 0) |
{ |
pos_b = -pos_b; |
num_of_neg ++; |
} |
#endif |
|
/* Left shift pos_a to {r, s} by FBITS. */ |
#if FBITS == FIXED_WIDTH |
/* This happens only for unsigned types without any padding bits. */ |
r = pos_a; |
s = 0; |
#else |
s = pos_a << FBITS; |
r = pos_a >> (FIXED_WIDTH - FBITS); |
#endif |
|
/* Unsigned divide r by pos_b to quo_r. The remainder is in mod. */ |
quo_r = (UINT_C_TYPE)r / (UINT_C_TYPE)pos_b; |
mod = (UINT_C_TYPE)r % (UINT_C_TYPE)pos_b; |
quo_s = 0; |
|
for (i = 0; i < FIXED_WIDTH; i++) |
{ |
/* Record the leftmost bit of mod. */ |
word_type leftmost_mode = (mod >> (FIXED_WIDTH - 1)) & 1; |
/* Shift left mod by 1 bit. */ |
mod = mod << 1; |
/* Test the leftmost bit of s to add to mod. */ |
if ((s >> (FIXED_WIDTH - 1)) & 1) |
mod ++; |
/* Shift left quo_s by 1 bit. */ |
quo_s = quo_s << 1; |
/* Try to calculate (mod - pos_b). */ |
temp = mod - pos_b; |
if (leftmost_mode || (UINT_C_TYPE)mod >= (UINT_C_TYPE)pos_b) |
{ |
quo_s ++; |
mod = temp; |
} |
/* Shift left s by 1 bit. */ |
s = s << 1; |
} |
|
#if MODE_UNSIGNED == 0 |
if (num_of_neg == 1) |
{ |
quo_s = -quo_s; |
if (quo_s == 0) |
quo_r = -quo_r; |
else |
quo_r = ~quo_r; |
} |
#endif |
if (satp) |
FIXED_SATURATE2 (&quo_r, &quo_s); |
z = quo_s; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
#endif |
} |
#endif /* FIXED_DIVHELPER */ |
|
#if defined(FIXED_DIV) && defined(L_div) |
FIXED_C_TYPE |
FIXED_DIV (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_DIVHELPER (a, b, 0); |
} |
#endif /* FIXED_DIV */ |
|
|
#if defined(FIXED_UDIV) && defined(L_udiv) |
FIXED_C_TYPE |
FIXED_UDIV (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_DIVHELPER (a, b, 0); |
} |
#endif /* FIXED_UDIV */ |
|
#if defined(FIXED_SSDIV) && defined(L_ssdiv) |
FIXED_C_TYPE |
FIXED_SSDIV (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_DIVHELPER (a, b, 1); |
} |
#endif /* FIXED_SSDIV */ |
|
#if defined(FIXED_USDIV) && defined(L_usdiv) |
FIXED_C_TYPE |
FIXED_USDIV (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
return FIXED_DIVHELPER (a, b, 1); |
} |
#endif /* FIXED_USDIV */ |
|
#if defined(FIXED_NEG) && defined(L_neg) |
FIXED_C_TYPE |
FIXED_NEG (FIXED_C_TYPE a) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, z; |
memcpy (&x, &a, FIXED_SIZE); |
z = -x; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_NEG */ |
|
#if defined(FIXED_SSNEG) && defined(L_ssneg) |
FIXED_C_TYPE |
FIXED_SSNEG (FIXED_C_TYPE a) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, y, z; |
memcpy (&y, &a, FIXED_SIZE); |
x = 0; |
z = x - (UINT_C_TYPE) y; |
if (((x ^ y) >> I_F_BITS) & 1) |
{ |
if (((z ^ x) >> I_F_BITS) & 1) |
z = (((UINT_C_TYPE) 1) << I_F_BITS) - 1; |
} |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_SSNEG */ |
|
#if defined(FIXED_USNEG) && defined(L_usneg) |
FIXED_C_TYPE |
FIXED_USNEG (FIXED_C_TYPE a __attribute__ ((__unused__))) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE z; |
z = 0; |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_USNEG */ |
|
#if defined(FIXED_ASHLHELPER) && defined(L_ashlhelper) |
FIXED_C_TYPE |
FIXED_ASHLHELPER (FIXED_C_TYPE a, word_type b, word_type satp) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, z; |
|
#if defined (DINT_C_TYPE) |
DINT_C_TYPE dx, dz; |
memcpy (&x, &a, FIXED_SIZE); |
dx = (DINT_C_TYPE) x; |
if (b >= FIXED_WIDTH) |
dz = dx << FIXED_WIDTH; |
else |
dz = dx << b; |
if (satp) |
FIXED_SATURATE1 (&dz); |
z = (INT_C_TYPE) dz; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
|
#else /* No DINT_C_TYPE */ |
INT_C_TYPE r, s; |
memcpy (&x, &a, FIXED_SIZE); |
/* We need to shift left x by b bits to {r, s}. */ |
if (b >= FIXED_WIDTH) |
{ |
r = b; |
s = 0; |
} |
else |
{ |
s = x << b; |
r = x >> (FIXED_WIDTH - b); |
} |
if (satp) |
FIXED_SATURATE2 (&r, &s); |
z = s; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
#endif |
} |
#endif /* FIXED_ASHLHELPER */ |
|
#if defined(FIXED_ASHL) && defined(L_ashl) |
FIXED_C_TYPE |
FIXED_ASHL (FIXED_C_TYPE a, word_type b) |
{ |
return FIXED_ASHLHELPER (a, b, 0); |
} |
#endif /* FIXED_ASHL */ |
|
#if defined(FIXED_ASHR) && defined(L_ashr) |
FIXED_C_TYPE |
FIXED_ASHR (FIXED_C_TYPE a, word_type b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, z; |
memcpy (&x, &a, FIXED_SIZE); |
z = x >> b; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_ASHR */ |
|
#if defined(FIXED_LSHR) && defined(L_lshr) |
FIXED_C_TYPE |
FIXED_LSHR (FIXED_C_TYPE a, word_type b) |
{ |
FIXED_C_TYPE c; |
INT_C_TYPE x, z; |
memcpy (&x, &a, FIXED_SIZE); |
z = x >> b; |
#if HAVE_PADDING_BITS |
z = z << PADDING_BITS; |
z = z >> PADDING_BITS; |
#endif |
memcpy (&c, &z, FIXED_SIZE); |
return c; |
} |
#endif /* FIXED_LSHR */ |
|
#if defined(FIXED_SSASHL) && defined(L_ssashl) |
FIXED_C_TYPE |
FIXED_SSASHL (FIXED_C_TYPE a, word_type b) |
{ |
return FIXED_ASHLHELPER (a, b, 1); |
} |
#endif /* FIXED_SSASHL */ |
|
#if defined(FIXED_USASHL) && defined(L_usashl) |
FIXED_C_TYPE |
FIXED_USASHL (FIXED_C_TYPE a, word_type b) |
{ |
return FIXED_ASHLHELPER (a, b, 1); |
} |
#endif /* FIXED_USASHL */ |
|
#if defined(FIXED_CMP) && defined(L_cmp) |
word_type |
FIXED_CMP (FIXED_C_TYPE a, FIXED_C_TYPE b) |
{ |
INT_C_TYPE x, y; |
memcpy (&x, &a, FIXED_SIZE); |
memcpy (&y, &b, FIXED_SIZE); |
|
if (x < y) |
return 0; |
else if (x > y) |
return 2; |
|
return 1; |
} |
#endif /* FIXED_CMP */ |
|
/* Fixed -> Fixed. */ |
#if defined(FRACT) && defined(L_fract) && FROM_TYPE == 4 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
FRACT (FROM_FIXED_C_TYPE a) |
{ |
TO_FIXED_C_TYPE c; |
FROM_INT_C_TYPE x; |
TO_INT_C_TYPE z; |
int shift_amount; |
memcpy (&x, &a, FROM_FIXED_SIZE); |
#if TO_FBITS > FROM_FBITS /* Need left shift. */ |
shift_amount = TO_FBITS - FROM_FBITS; |
z = (TO_INT_C_TYPE) x; |
z = z << shift_amount; |
#else /* TO_FBITS <= FROM_FBITS. Need right Shift. */ |
shift_amount = FROM_FBITS - TO_FBITS; |
x = x >> shift_amount; |
z = (TO_INT_C_TYPE) x; |
#endif /* TO_FBITS > FROM_FBITS */ |
|
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* FRACT && FROM_TYPE == 4 && TO_TYPE == 4 */ |
|
/* Fixed -> Fixed with saturation. */ |
#if defined(SATFRACT) && defined(L_satfract) && FROM_TYPE == 4 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
SATFRACT (FROM_FIXED_C_TYPE a) |
{ |
TO_FIXED_C_TYPE c; |
TO_INT_C_TYPE z; |
FROM_INT_C_TYPE x; |
#if FROM_MODE_UNSIGNED == 0 |
BIG_SINT_C_TYPE high, low; |
BIG_SINT_C_TYPE max_high, max_low; |
#if TO_MODE_UNSIGNED == 0 |
BIG_SINT_C_TYPE min_high, min_low; |
#endif |
#else |
BIG_UINT_C_TYPE high, low; |
BIG_UINT_C_TYPE max_high, max_low; |
#endif |
#if TO_FBITS > FROM_FBITS |
BIG_UINT_C_TYPE utemp; |
#endif |
#if TO_MODE_UNSIGNED == 0 |
BIG_SINT_C_TYPE stemp; |
#endif |
#if TO_FBITS != FROM_FBITS |
int shift_amount; |
#endif |
memcpy (&x, &a, FROM_FIXED_SIZE); |
|
/* Step 1. We need to store x to {high, low}. */ |
#if FROM_MODE_UNSIGNED == 0 |
low = (BIG_SINT_C_TYPE) x; |
if (x < 0) |
high = -1; |
else |
high = 0; |
#else |
low = (BIG_UINT_C_TYPE) x; |
high = 0; |
#endif |
|
/* Step 2. We need to shift {high, low}. */ |
#if TO_FBITS > FROM_FBITS /* Left shift. */ |
shift_amount = TO_FBITS - FROM_FBITS; |
utemp = (BIG_UINT_C_TYPE) low; |
utemp = utemp >> (BIG_WIDTH - shift_amount); |
high = ((BIG_UINT_C_TYPE)(high << shift_amount)) | utemp; |
low = low << shift_amount; |
#elif TO_FBITS < FROM_FBITS /* Right shift. */ |
shift_amount = FROM_FBITS - TO_FBITS; |
low = low >> shift_amount; |
#endif |
|
/* Step 3. Compare {high, low} with max and min of TO_FIXED_C_TYPE. */ |
max_high = 0; |
#if BIG_WIDTH > TO_FIXED_WIDTH || TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS |
max_low = (BIG_UINT_C_TYPE)1 << TO_I_F_BITS; |
max_low = max_low - 1; |
#else |
max_low = -1; |
#endif |
|
#if TO_MODE_UNSIGNED == 0 |
stemp = (BIG_SINT_C_TYPE)1 << (BIG_WIDTH - 1); |
stemp = stemp >> (BIG_WIDTH - 1 - TO_I_F_BITS); |
#if FROM_MODE_UNSIGNED == 0 |
min_high = -1; |
min_low = stemp; |
#endif |
#endif |
|
#if FROM_MODE_UNSIGNED == 0 && TO_MODE_UNSIGNED == 0 |
/* Signed -> Signed. */ |
if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high |
|| ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
else if ((BIG_SINT_C_TYPE) high < (BIG_SINT_C_TYPE) min_high |
|| ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) min_high |
&& (BIG_UINT_C_TYPE) low < (BIG_UINT_C_TYPE) min_low)) |
low = min_low; /* Minimum. */ |
#elif FROM_MODE_UNSIGNED == 1 && TO_MODE_UNSIGNED == 1 |
/* Unigned -> Unsigned. */ |
if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high |
|| ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
#elif FROM_MODE_UNSIGNED == 0 && TO_MODE_UNSIGNED == 1 |
/* Signed -> Unsigned. */ |
if (x < 0) |
low = 0; /* Minimum. */ |
else if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high |
|| ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
#elif FROM_MODE_UNSIGNED == 1 && TO_MODE_UNSIGNED == 0 |
/* Unsigned -> Signed. */ |
if ((BIG_SINT_C_TYPE) high < 0) |
low = max_low; /* Maximum. */ |
else if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high |
|| ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
#endif |
|
/* Step 4. Store the result. */ |
z = (TO_INT_C_TYPE) low; |
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(SATFRACT) && FROM_TYPE == 4 && TO_TYPE == 4 */ |
|
/* Fixed -> Int. */ |
#if defined(FRACT) && defined(L_fract) && FROM_TYPE == 4 && TO_TYPE == 1 |
TO_INT_C_TYPE |
FRACT (FROM_FIXED_C_TYPE a) |
{ |
FROM_INT_C_TYPE x; |
TO_INT_C_TYPE z; |
FROM_INT_C_TYPE i = 0; |
memcpy (&x, &a, FROM_FIXED_SIZE); |
|
#if FROM_MODE_UNSIGNED == 0 |
if (x < 0) |
{ |
#if FROM_FIXED_WIDTH == FROM_FBITS |
if (x != 0) |
i = 1; |
#else |
if (((FROM_INT_C_TYPE)(x << (FROM_FIXED_WIDTH - FROM_FBITS))) != 0) |
i = 1; |
#endif |
} |
#endif |
|
#if FROM_FIXED_WIDTH == FROM_FBITS |
x = 0; |
#else |
x = x >> FROM_FBITS; |
#endif |
x = x + i; |
z = (TO_INT_C_TYPE) x; |
return z; |
} |
#endif /* defined(FRACT) && FROM_TYPE == 4 && TO_TYPE == 1 */ |
|
/* Fixed -> Unsigned int. */ |
#if defined(FRACTUNS) && defined(L_fractuns) && FROM_TYPE == 4 && TO_TYPE == 2 |
TO_INT_C_TYPE |
FRACTUNS (FROM_FIXED_C_TYPE a) |
{ |
FROM_INT_C_TYPE x; |
TO_INT_C_TYPE z; |
FROM_INT_C_TYPE i = 0; |
memcpy (&x, &a, FROM_FIXED_SIZE); |
|
#if FROM_MODE_UNSIGNED == 0 |
if (x < 0) |
{ |
#if FROM_FIXED_WIDTH == FROM_FBITS |
if (x != 0) |
i = 1; |
#else |
if (((FROM_INT_C_TYPE)(x << (FROM_FIXED_WIDTH - FROM_FBITS))) != 0) |
i = 1; |
#endif |
} |
#endif |
|
#if FROM_FIXED_WIDTH == FROM_FBITS |
x = 0; |
#else |
x = x >> FROM_FBITS; |
#endif |
x = x + i; |
z = (TO_INT_C_TYPE) x; |
return z; |
} |
#endif /* defined(FRACTUNS) && FROM_TYPE == 4 && TO_TYPE == 2 */ |
|
/* Int -> Fixed. */ |
#if defined(FRACT) && defined(L_fract) && FROM_TYPE == 1 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
FRACT (FROM_INT_C_TYPE a) |
{ |
TO_FIXED_C_TYPE c; |
TO_INT_C_TYPE z; |
z = (TO_INT_C_TYPE) a; |
#if TO_FIXED_WIDTH == TO_FBITS |
z = 0; |
#else |
z = z << TO_FBITS; |
#endif |
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(FRACT) && FROM_TYPE == 1 && TO_TYPE == 4 */ |
|
/* Signed int -> Fixed with saturation. */ |
#if defined(SATFRACT) && defined(L_satfract) && FROM_TYPE == 1 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
SATFRACT (FROM_INT_C_TYPE a) |
{ |
TO_FIXED_C_TYPE c; |
TO_INT_C_TYPE z; |
FROM_INT_C_TYPE x = a; |
BIG_SINT_C_TYPE high, low; |
BIG_SINT_C_TYPE max_high, max_low; |
#if TO_MODE_UNSIGNED == 0 |
BIG_SINT_C_TYPE min_high, min_low; |
BIG_SINT_C_TYPE stemp; |
#endif |
#if BIG_WIDTH != TO_FBITS |
BIG_UINT_C_TYPE utemp; |
int shift_amount; |
#endif |
|
/* Step 1. We need to store x to {high, low}. */ |
low = (BIG_SINT_C_TYPE) x; |
if (x < 0) |
high = -1; |
else |
high = 0; |
|
/* Step 2. We need to left shift {high, low}. */ |
#if BIG_WIDTH == TO_FBITS |
high = low; |
low = 0; |
#else |
shift_amount = TO_FBITS; |
utemp = (BIG_UINT_C_TYPE) low; |
utemp = utemp >> (BIG_WIDTH - shift_amount); |
high = ((BIG_UINT_C_TYPE)(high << shift_amount)) | utemp; |
low = low << shift_amount; |
#endif |
|
/* Step 3. Compare {high, low} with max and min of TO_FIXED_C_TYPE. */ |
max_high = 0; |
#if BIG_WIDTH > TO_FIXED_WIDTH || TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS |
max_low = (BIG_UINT_C_TYPE)1 << TO_I_F_BITS; |
max_low = max_low - 1; |
#else |
max_low = -1; |
#endif |
|
#if TO_MODE_UNSIGNED == 0 |
min_high = -1; |
stemp = (BIG_SINT_C_TYPE)1 << (BIG_WIDTH - 1); |
stemp = stemp >> (BIG_WIDTH - 1 - TO_I_F_BITS); |
min_low = stemp; |
|
/* Signed -> Signed. */ |
if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high |
|| ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
else if ((BIG_SINT_C_TYPE) high < (BIG_SINT_C_TYPE) min_high |
|| ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) min_high |
&& (BIG_UINT_C_TYPE) low < (BIG_UINT_C_TYPE) min_low)) |
low = min_low; /* Minimum. */ |
#else |
/* Signed -> Unsigned. */ |
if (x < 0) |
low = 0; /* Minimum. */ |
else if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high |
|| ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
#endif |
|
/* Step 4. Store the result. */ |
z = (TO_INT_C_TYPE) low; |
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(SATFRACT) && FROM_TYPE == 1 && TO_TYPE == 4 */ |
|
/* Unsigned int -> Fixed. */ |
#if defined(FRACTUNS) && defined(L_fractuns) &&FROM_TYPE == 2 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
FRACTUNS (FROM_INT_C_TYPE a) |
{ |
TO_FIXED_C_TYPE c; |
TO_INT_C_TYPE z; |
z = (TO_INT_C_TYPE) a; |
#if TO_FIXED_WIDTH == TO_FBITS |
z = 0; |
#else |
z = z << TO_FBITS; |
#endif |
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(FRACTUNS) && FROM_TYPE == 2 && TO_TYPE == 4 */ |
|
/* Unsigned int -> Fixed with saturation. */ |
#if defined(SATFRACTUNS) && defined(L_satfractuns) && FROM_TYPE == 2 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
SATFRACTUNS (FROM_INT_C_TYPE a) |
{ |
TO_FIXED_C_TYPE c; |
TO_INT_C_TYPE z; |
FROM_INT_C_TYPE x = a; |
BIG_UINT_C_TYPE high, low; |
BIG_UINT_C_TYPE max_high, max_low; |
#if BIG_WIDTH != TO_FBITS |
BIG_UINT_C_TYPE utemp; |
int shift_amount; |
#endif |
|
/* Step 1. We need to store x to {high, low}. */ |
low = (BIG_UINT_C_TYPE) x; |
high = 0; |
|
/* Step 2. We need to left shift {high, low}. */ |
#if BIG_WIDTH == TO_FBITS |
high = low; |
low = 0; |
#else |
shift_amount = TO_FBITS; |
utemp = (BIG_UINT_C_TYPE) low; |
utemp = utemp >> (BIG_WIDTH - shift_amount); |
high = ((BIG_UINT_C_TYPE)(high << shift_amount)) | utemp; |
low = low << shift_amount; |
#endif |
|
/* Step 3. Compare {high, low} with max and min of TO_FIXED_C_TYPE. */ |
max_high = 0; |
#if BIG_WIDTH > TO_FIXED_WIDTH || TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS |
max_low = (BIG_UINT_C_TYPE)1 << TO_I_F_BITS; |
max_low = max_low - 1; |
#else |
max_low = -1; |
#endif |
|
#if TO_MODE_UNSIGNED == 1 |
/* Unigned -> Unsigned. */ |
if ((BIG_UINT_C_TYPE) high > (BIG_UINT_C_TYPE) max_high |
|| ((BIG_UINT_C_TYPE) high == (BIG_UINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
#else |
/* Unsigned -> Signed. */ |
if ((BIG_SINT_C_TYPE) high < 0) |
low = max_low; /* Maximum. */ |
else if ((BIG_SINT_C_TYPE) high > (BIG_SINT_C_TYPE) max_high |
|| ((BIG_SINT_C_TYPE) high == (BIG_SINT_C_TYPE) max_high |
&& (BIG_UINT_C_TYPE) low > (BIG_UINT_C_TYPE) max_low)) |
low = max_low; /* Maximum. */ |
#endif |
|
/* Step 4. Store the result. */ |
z = (TO_INT_C_TYPE) low; |
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(SATFRACTUNS) && FROM_TYPE == 2 && TO_TYPE == 4 */ |
|
/* Fixed -> Float. */ |
#if defined(FRACT) && defined(L_fract) && FROM_TYPE == 4 && TO_TYPE == 3 |
TO_FLOAT_C_TYPE |
FRACT (FROM_FIXED_C_TYPE a) |
{ |
FROM_INT_C_TYPE x; |
TO_FLOAT_C_TYPE z; |
memcpy (&x, &a, FROM_FIXED_SIZE); |
z = (TO_FLOAT_C_TYPE) x; |
z = z / BASE; |
return z; |
} |
#endif /* defined(FRACT) && FROM_TYPE == 4 && TO_TYPE == 3 */ |
|
/* Float -> Fixed. */ |
#if defined(FRACT) && defined(L_fract) && FROM_TYPE == 3 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
FRACT (FROM_FLOAT_C_TYPE a) |
{ |
FROM_FLOAT_C_TYPE temp; |
TO_INT_C_TYPE z; |
TO_FIXED_C_TYPE c; |
|
temp = a * BASE; |
z = (TO_INT_C_TYPE) temp; |
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(FRACT) && FROM_TYPE == 3 && TO_TYPE == 4 */ |
|
/* Float -> Fixed with saturation. */ |
#if defined(SATFRACT) && defined(L_satfract) && FROM_TYPE == 3 && TO_TYPE == 4 |
TO_FIXED_C_TYPE |
SATFRACT (FROM_FLOAT_C_TYPE a) |
{ |
FROM_FLOAT_C_TYPE temp; |
TO_INT_C_TYPE z; |
TO_FIXED_C_TYPE c; |
|
if (a >= FIXED_MAX) |
{ |
#if TO_MODE_UNSIGNED == 0 || TO_HAVE_PADDING_BITS |
z = (TO_INT_C_TYPE)1 << TO_I_F_BITS; |
z = z - 1; |
#else |
z = -1; |
#endif |
} |
else if (a <= FIXED_MIN) |
{ |
#if TO_MODE_UNSIGNED == 0 |
z = (TO_INT_C_TYPE)1 << TO_I_F_BITS; |
#else |
z = 0; |
#endif |
} |
else |
{ |
temp = a * BASE; |
z = (TO_INT_C_TYPE) temp; |
} |
|
#if TO_HAVE_PADDING_BITS |
z = z << TO_PADDING_BITS; |
z = z >> TO_PADDING_BITS; |
#endif |
memcpy (&c, &z, TO_FIXED_SIZE); |
return c; |
} |
#endif /* defined(SATFRACT) && FROM_TYPE == 3 && TO_TYPE == 4 */ |
|