c92b617397
If you develop on windows and need cr/lf files, see this:
https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration#_formatting_and_whitespace
Git can handle this by auto-converting CRLF line endings into LF
when you add a file to the index, and vice versa when it checks out
code onto your filesystem. You can turn on this functionality with
the core.autocrlf setting. If you're on a Windows machine, set it
to true - this converts LF endings into CRLF when you check out code:
$ git config --global core.autocrlf true
1759 lines
39 KiB
C
Executable File
1759 lines
39 KiB
C
Executable File
/*
|
|
* Copyright (c) 2006-2010 Tensilica Inc. ALL RIGHTS RESERVED.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#ifndef __C6X_COMPAT__H
|
|
#define __C6X_COMPAT__H
|
|
|
|
/* Unimplemented functions _gmpy, _gmpy4, _xormpy, _lssub, _cmpy, _cmpyr,
|
|
_cmpyr1, _ddotpl2r, _ddotph2r */
|
|
|
|
|
|
typedef long long C6X_COMPAT_LONG40;
|
|
|
|
|
|
#define _memd8(a) (*((double*)(a)))
|
|
#define _memd8_const(a) (*((const double*)(a)))
|
|
|
|
#define _amemd8(a) (*((double*)(a)))
|
|
#define _amemd8_const(a) (*((const double*)(a)))
|
|
|
|
#define _mem8(a) (*((unsigned long long*)(a)))
|
|
#define _mem8_const(a) (*((const unsigned long long*)(a)))
|
|
|
|
#define _mem4(a) (*((unsigned*)(a)))
|
|
#define _mem4_const(a) (*((const unsigned*)(a)))
|
|
#define _amem4_const(a) (*((const unsigned*)(a)))
|
|
|
|
/* NOTE: To emulate a C6X properly you should define global variables
|
|
for your Xtensa with these names. Some of the emulation routines
|
|
will set these values. */
|
|
|
|
extern int _carry;
|
|
extern int _overflow;
|
|
|
|
// Utility routines
|
|
|
|
|
|
#define TESTBIT(x,n) (((x) >> (n)) & 1)
|
|
|
|
#define NSA_BITS 32
|
|
|
|
static inline unsigned int norm_shift_amt_U_and_non_U(int is_signed, int inp) {
|
|
int j=0, k=0;
|
|
int x=inp;
|
|
if (is_signed) {
|
|
/* Invert signed val if negative */
|
|
x= TESTBIT(x,(NSA_BITS-1))? ~x: x;
|
|
x= (x&1)|(x<<1); /* Shift up to return count-1 */
|
|
if (x ==0)
|
|
return NSA_BITS-1;
|
|
}
|
|
if (x ==0)
|
|
return NSA_BITS;
|
|
/* Now count leading zeros */
|
|
for (j=0, k=NSA_BITS-1; k>=0; j++, k--) {
|
|
if (TESTBIT(x,k))
|
|
return j;
|
|
}
|
|
return NSA_BITS;
|
|
}
|
|
|
|
|
|
|
|
static inline long long
|
|
orig_L40_set( long long L40_var1) {
|
|
long long L40_var_out;
|
|
|
|
L40_var_out = L40_var1 & 0x000000ffffffffffLL;
|
|
|
|
if( L40_var1 & 0x8000000000LL)
|
|
L40_var_out = L40_var_out | 0xffffff0000000000LL;
|
|
|
|
return( L40_var_out);
|
|
}
|
|
|
|
|
|
|
|
static inline signed long long
|
|
util_saturate_n_no_state(signed long long t, int n)
|
|
{
|
|
signed long long maxv, minv;
|
|
maxv = (1LL << (n-1)) - 1;
|
|
minv = (-1LL << (n-1));
|
|
if (t > maxv) {
|
|
t = maxv;
|
|
} else if (t < minv) {
|
|
t = minv;
|
|
}
|
|
return t;
|
|
}
|
|
|
|
|
|
static inline signed long long
|
|
util_saturate_n_sgn(signed long long t, int n)
|
|
{
|
|
signed long long result;
|
|
signed long long maxv, minv;
|
|
maxv = (1LL << (n-1)) - 1;
|
|
minv = (-1LL << (n-1));
|
|
if (t > 0) {
|
|
result = maxv;
|
|
_overflow = 1;
|
|
} else if (t < 0) {
|
|
result = minv;
|
|
_overflow = 1;
|
|
} else {
|
|
result = 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* well-behaved signed shift right (left on negative) with
|
|
saturation */
|
|
static inline signed long long
|
|
util_shift_right_saturate_n(signed long long t, int shval, int n)
|
|
{
|
|
/* n should be <= 62 */
|
|
long long result;
|
|
|
|
signed long long mask;
|
|
int actual_shift = shval;
|
|
long long shft = actual_shift > 0 ? actual_shift : -actual_shift;
|
|
|
|
if (t == 0 || actual_shift == 0)
|
|
return t;
|
|
|
|
if (actual_shift >= n) {
|
|
return (t < 0) ? -1 : 0;
|
|
}
|
|
if (actual_shift <= -n) {
|
|
return util_saturate_n_sgn(t, n);
|
|
}
|
|
if (actual_shift > 0) {
|
|
return t >> actual_shift;
|
|
}
|
|
/* actual_shift < 0. Check for saturation after shift. */
|
|
mask = (-1LL << (n-shft-1));
|
|
if (t > 0 && ((mask & t) != 0)) {
|
|
return util_saturate_n_sgn(t, n);
|
|
}
|
|
if (t < 0 && ((mask & t) != mask)) {
|
|
return util_saturate_n_sgn(t, n);
|
|
}
|
|
result = t << shft;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Implemented c6x standard C compatibility functions (alphabetical
|
|
order) */
|
|
|
|
|
|
static inline int _abs(int src1) {
|
|
if ((unsigned) src1 == (unsigned) 0x80000000) {
|
|
return 0x7fffffff;
|
|
}
|
|
return abs(src1);
|
|
}
|
|
|
|
|
|
static inline int _abs2(int src1) {
|
|
short s1[2],r[2];
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
if ((unsigned short) s1[1] == (unsigned short) 0x8000) r[1] = 0x7fff;
|
|
else r[1] = abs(s1[1]);
|
|
if ((unsigned short) s1[0] == (unsigned short) 0x8000) r[0] = 0x7fff;
|
|
else r[0] = abs(s1[0]);
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int _add2(int src1, int src2) {
|
|
short s1[2], s2[2], r[2];
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r[0] = s1[0] + s2[0];
|
|
r[1] = s1[1] + s2[1];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
static inline int _add4(int src1, int src2) {
|
|
char c1[4], c2[4], r[4];
|
|
int result;
|
|
*((int*)c1) = src1;
|
|
*((int*)c2) = src2;
|
|
r[0] = c1[0] + c2[0];
|
|
r[1] = c1[1] + c2[1];
|
|
r[2] = c1[2] + c2[2];
|
|
r[3] = c1[3] + c2[3];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
static inline long long _addsub(unsigned int src1, unsigned int src2)
|
|
{
|
|
|
|
int res_lo;
|
|
int res_hi;
|
|
|
|
res_hi = src1+src2;
|
|
res_lo = src1-src2;
|
|
return (((unsigned long long) res_hi) << 32) | ((unsigned int) res_lo) ;
|
|
}
|
|
|
|
|
|
static inline long long _addsub2(unsigned int src1, unsigned int src2)
|
|
{
|
|
short s1[2], s2[2], ra[2], rs[2];
|
|
int res_lo;
|
|
int res_hi;
|
|
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
ra[0] = s1[0] + s2[0];
|
|
ra[1] = s1[1] + s2[1];
|
|
rs[0] = s1[0] - s2[0];
|
|
rs[1] = s1[1] - s2[1];
|
|
|
|
res_hi = *(int*)ra;
|
|
res_lo = *(int*)rs;
|
|
return (((unsigned long long) res_hi) << 32) | ((unsigned int) res_lo) ;
|
|
}
|
|
|
|
|
|
static inline int _avg2(int src1, int src2) {
|
|
int low = (((int)1 + (short) src1 + (short) src2) >> 1) & 0XFFFF;
|
|
int high1 = src1 >> 16;
|
|
int high2 = src2 >> 16;
|
|
int high = ((high1 + high2 + 1) >> 1)<< 16;
|
|
return high | low;
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int _avgu4(unsigned int src1, unsigned int src2) {
|
|
unsigned int res0 = ((src1 & 0xFF) + (src2 & 0xFF) + 1) >> 1;
|
|
unsigned int res1 = (((src1 & 0xFF00) >> 8) + ((src2 & 0xFF00) >> 8) + 1) >> 1;
|
|
unsigned int res2 = (((src1 & 0xFF0000) >> 16) + ((src2 & 0xFF0000) >> 16) + 1) >> 1;
|
|
unsigned int res3 = (((src1 & 0xFF000000) >> 24) + ((src2 & 0xFF000000) >> 24) + 1) >> 1;
|
|
return (res3 << 24) | (res2 << 16) | (res1 << 8) | res0;
|
|
}
|
|
|
|
|
|
static inline int TEN_popc (unsigned char b)
|
|
{
|
|
int i, result = 0;
|
|
for (i = 0; i < 8; i++){
|
|
if (b & 0x1)
|
|
result++;
|
|
b >>= 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static inline unsigned int _bitc4(unsigned int src1)
|
|
{
|
|
unsigned int res0 = TEN_popc(src1 & 0xFF);
|
|
unsigned int res1 = TEN_popc((src1 & 0xFF00) >> 8);
|
|
unsigned int res2 = TEN_popc((src1 & 0xFF0000) >> 16);
|
|
unsigned int res3 = TEN_popc((src1 & 0xFF000000) >> 24);
|
|
return (res3 << 24) | (res2 << 16) | (res1 << 8) | res0;
|
|
}
|
|
|
|
static inline unsigned int _bitr(unsigned int src) {
|
|
int i;
|
|
unsigned r = 0;
|
|
for (i = 0; i< 32; ++i) {
|
|
r = r | (((src >> i) & 1)<<(31-i));
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
static inline unsigned int _clr(unsigned int src2, int csta, int cstb)
|
|
{
|
|
csta &= 0x1f;
|
|
cstb &= 0x1f;
|
|
if (csta > cstb)
|
|
return src2;
|
|
else {
|
|
unsigned int mask = (((1 << (cstb - csta)) << 1) - 1) << csta;
|
|
return src2 & (~mask);
|
|
}
|
|
}
|
|
|
|
static inline unsigned int _clrr(unsigned int src2, int src1)
|
|
{
|
|
unsigned int csta = (src1 >> 5) & 0x1f;
|
|
unsigned int cstb = src1 & 0x1f;
|
|
if (csta > cstb)
|
|
return src2;
|
|
else {
|
|
unsigned int mask = (((1 << (cstb - csta)) << 1) - 1) << csta;
|
|
return src2 & (~mask);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int _cmpeq2(int src1, int src2) {
|
|
short s1[2], s2[2];
|
|
int r0, r1;
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r0 = s1[0] == s2[0] ? 1 : 0;
|
|
r1 = s1[1] == s2[1] ? 1 : 0;
|
|
result = (r1 << 1) | r0;
|
|
return result;
|
|
}
|
|
|
|
static inline int _cmpeq4(int src1, int src2) {
|
|
char s1[4], s2[4];
|
|
int r0, r1, r2, r3;
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r0 = s1[0] == s2[0] ? 1 : 0;
|
|
r1 = s1[1] == s2[1] ? 1 : 0;
|
|
r2 = s1[2] == s2[2] ? 1 : 0;
|
|
r3 = s1[3] == s2[3] ? 1 : 0;
|
|
result = (r3 << 3) | (r2 << 2) | (r1 << 1) | r0;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline int _cmpgt2(int src1, int src2) {
|
|
short s1[2], s2[2];
|
|
int r1, r0;
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r0 = s1[0] > s2[0] ? 1 : 0;
|
|
r1 = s1[1] > s2[1] ? 1 : 0;
|
|
result = (r1<<1) | r0;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline unsigned int _cmpgtu4(unsigned int src1, unsigned int src2) {
|
|
unsigned int s1_0 = (src1 & 0xFF);
|
|
unsigned int s1_1 = (src1 & 0xFF00) >> 8;
|
|
unsigned int s1_2 = (src1 & 0xFF0000) >> 16;
|
|
unsigned int s1_3 = (src1 & 0xFF000000) >> 24;
|
|
|
|
unsigned int s2_0 = (src2 & 0xFF);
|
|
unsigned int s2_1 = (src2 & 0xFF00) >> 8;
|
|
unsigned int s2_2 = (src2 & 0xFF0000) >> 16;
|
|
unsigned int s2_3 = (src2 & 0xFF000000) >> 24;
|
|
|
|
unsigned int result = 0;
|
|
|
|
if (s1_0 > s2_0)
|
|
result |= 0x1;
|
|
|
|
if (s1_1 > s2_1)
|
|
result |= 0x2;
|
|
|
|
if (s1_2 > s2_2)
|
|
result |= 0x4;
|
|
|
|
if (s1_3 > s2_3)
|
|
result |= 0x8;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline long long _ddotp4(unsigned int src1, unsigned int src2) {
|
|
unsigned int res0, res1;
|
|
short s1_0 = (src1 & 0xffff);
|
|
short s1_1 = (src1 & 0xfff0000) >> 16;
|
|
|
|
unsigned short s2_0 = (src2 & 0xff);
|
|
unsigned short s2_1 = (src2 & 0xff00) >> 8;
|
|
unsigned short s2_2 = (src2 & 0xff0000) >> 16;
|
|
unsigned short s2_3 = (src2 & 0xff000000) >> 24;
|
|
|
|
res0 = ((int)s1_0) * s2_0 + ((int)s1_1) * s2_1;
|
|
res1 = ((int)s1_0) * s2_2 + ((int)s1_1) * s2_3;
|
|
|
|
return (res1 << 16) | res0;
|
|
}
|
|
|
|
|
|
static inline long long _ddotph2(long long src1_o_src1_e, unsigned int src2)
|
|
{
|
|
|
|
unsigned int src1_o = src1_o_src1_e >> 32;
|
|
unsigned int src1_e = src1_o_src1_e & 0xFFFFFFFF;
|
|
short ls1_o = src1_o & 0XFFFF;
|
|
short hs1_o = src1_o >> 16;
|
|
// short ls1_e = src1_e & 0XFFFF;
|
|
short hs1_e = src1_e >> 16;
|
|
short ls2 = src2 & 0XFFFF;
|
|
short hs2 = src2 >> 16;
|
|
|
|
unsigned long long res_hi = ls2 * ls1_o + hs2 * hs1_o;
|
|
unsigned int res_lo = ls1_o * hs2 + hs1_e * ls2;
|
|
return (res_hi << 32) | res_lo;
|
|
}
|
|
|
|
|
|
static inline long long _ddotpl2(long long src1_o_src1_e, unsigned int src2)
|
|
{
|
|
unsigned int src1_o = src1_o_src1_e >> 32;
|
|
unsigned int src1_e = src1_o_src1_e & 0xFFFFFFFF;
|
|
short ls1_o = src1_o & 0XFFFF;
|
|
// short hs1_o = src1_o >> 16;
|
|
short ls1_e = src1_e & 0XFFFF;
|
|
short hs1_e = src1_e >> 16;
|
|
short ls2 = src2 & 0XFFFF;
|
|
short hs2 = src2 >> 16;
|
|
|
|
unsigned long long res_hi = ls2 * hs1_e + hs2 * ls1_o;
|
|
unsigned res_lo = hs1_e * hs2 + ls1_e * ls2;
|
|
return (res_hi << 32) | res_lo;
|
|
}
|
|
|
|
|
|
static inline unsigned int _deal(unsigned int src)
|
|
{
|
|
int i;
|
|
unsigned short lo = 0, hi = 0;
|
|
for (i = 0; i < 32; i+= 2) {
|
|
lo >>= 1;
|
|
lo |= (src & 0x1) << 15;
|
|
src >>= 1;
|
|
hi >>= 1;
|
|
hi |= (src & 0x1) << 15;
|
|
src >>= 1;
|
|
}
|
|
return (hi << 16) | lo;
|
|
}
|
|
|
|
|
|
static inline long long _dmv(unsigned int src1, unsigned int src2)
|
|
{
|
|
return (((long long) src1) << 32) | src2;
|
|
}
|
|
|
|
|
|
static inline int _dotpn2(int src1, int src2) {
|
|
short int s1_h = src1>>16;
|
|
short int s1_l = src1;
|
|
short int s2_h = src2>>16;
|
|
short int s2_l = src2;
|
|
return s1_h * s2_h - s1_l * s2_l;
|
|
}
|
|
|
|
|
|
static inline int _dotp2(int src1, int src2) {
|
|
short int s1_h = src1>>16;
|
|
short int s1_l = src1;
|
|
short int s2_h = src2>>16;
|
|
short int s2_l = src2;
|
|
return s1_h * s2_h + s1_l * s2_l;
|
|
}
|
|
|
|
|
|
|
|
static inline int _dotpnrsu2(int src1, unsigned int src2)
|
|
{
|
|
short ls1 = src1 & 0XFFFF;
|
|
unsigned short ls2 = src2 & 0XFFFF;
|
|
short hs1 = src1 >> 16;
|
|
unsigned short hs2 = src2 >> 16;
|
|
|
|
int result = (((long long) (int)(hs1 * hs2)) - ((long long) (int)(ls1 * ls2)) + (1 << 15)) >> 16;
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
static inline int _dotprsu2(int src1, unsigned int src2) {
|
|
short ls1 = src1 & 0XFFFF;
|
|
unsigned short ls2 = (src2 & 0XFFFF);
|
|
short hs1 = src1 >> 16;
|
|
unsigned short hs2 = (src2 >> 16);
|
|
|
|
int result = (((long long) (int) (ls1 * ls2)) + ((long long) (int) (hs1 * hs2)) + (1LL << 15)) >> 16;
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline int _dotpsu4(int src1, unsigned int src2) {
|
|
int result;
|
|
signed char s1_0 = (src1 & 0xff);
|
|
signed char s1_1 = (src1 & 0xff00) >> 8;
|
|
signed char s1_2 = (src1 & 0xff0000) >> 16;
|
|
signed char s1_3 = (src1 & 0xff000000) >> 24;
|
|
|
|
unsigned int s2_0 = (src2 & 0xff);
|
|
unsigned int s2_1 = (src2 & 0xff00) >> 8;
|
|
unsigned int s2_2 = (src2 & 0xff0000) >> 16;
|
|
unsigned int s2_3 = (src2 & 0xff000000) >> 24;
|
|
|
|
result = s1_0 * s2_0 + s1_1 * s2_1 + s1_2 * s2_2 + s1_3 * s2_3;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline unsigned int _dotpu4(unsigned int src1, unsigned int src2) {
|
|
unsigned char v1_0 = src1 & 0xff;
|
|
unsigned char v1_1 = (src1>>8) & 0xff;
|
|
unsigned char v1_2 = (src1>>16) & 0xff;
|
|
unsigned char v1_3 = (src1>>24) & 0xff;
|
|
|
|
unsigned char v2_0 = src2 & 0xff;
|
|
unsigned char v2_1 = (src2>>8) & 0xff;
|
|
unsigned char v2_2 = (src2>>16) & 0xff;
|
|
unsigned char v2_3 = (src2>>24) & 0xff;
|
|
|
|
unsigned v = v1_0 * v2_0 + v1_1 * v2_1 + v1_2 * v2_2 + v1_3 * v2_3;
|
|
return v;
|
|
}
|
|
|
|
|
|
static inline long long _dpack2(unsigned int src1, unsigned int src2){
|
|
unsigned short s1[2], s2[2];
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
return ((unsigned long long) s1[1] << 48) | ((unsigned long long) s2[1] << 32) | ((unsigned long long) s1[0] << 16) | ((unsigned long long) s2[0]);
|
|
}
|
|
|
|
|
|
static inline long long _dpackx2(unsigned int src1, unsigned int src2){
|
|
unsigned short s1[2], s2[2];
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
return ((unsigned long long) s2[0] << 48) | ((unsigned long long) s1[1] << 32) | ((unsigned long long) s1[0] << 16) | ((unsigned long long) s2[1]);
|
|
}
|
|
|
|
static inline int _ext(int src2, unsigned int csta, unsigned int cstb)
|
|
{
|
|
return (src2 << csta) >> cstb;
|
|
}
|
|
|
|
static inline int _extr(int src2, int src1)
|
|
{
|
|
unsigned int csta = (src1 >> 5) & 0x1f;
|
|
unsigned int cstb = src1 & 0x1f;
|
|
return (src2 << csta) >> cstb;
|
|
}
|
|
|
|
static inline unsigned int _extu(unsigned int src2, unsigned int csta, unsigned int cstb)
|
|
{
|
|
return (src2 << csta) >> cstb;
|
|
}
|
|
|
|
static inline unsigned int _extur(unsigned int src2, int src1)
|
|
{
|
|
unsigned int csta = (src1 >> 5) & 0x1f;
|
|
unsigned int cstb = src1 & 0x1f;
|
|
return (src2 << csta) >> cstb;
|
|
}
|
|
|
|
|
|
static inline unsigned long long _hi(double src) {
|
|
unsigned long long v;
|
|
*(double*)&v = src;
|
|
return v>>32;
|
|
}
|
|
|
|
static inline unsigned int _hill (long long src)
|
|
{
|
|
return (unsigned int) (src >> 32);
|
|
}
|
|
|
|
|
|
|
|
static inline double _itod(unsigned hi, unsigned lo) {
|
|
double v;
|
|
unsigned long long ll = ((((unsigned long long)(hi))<<32) | (unsigned long long)((unsigned)lo));
|
|
*((unsigned long long *)&v) = ll;
|
|
return v;
|
|
}
|
|
|
|
|
|
static inline long long _itoll(unsigned int src2, unsigned int src1)
|
|
{
|
|
return (((long long) src2) << 32) | src1;
|
|
}
|
|
|
|
|
|
static inline C6X_COMPAT_LONG40 _labs(C6X_COMPAT_LONG40 src2)
|
|
{
|
|
long long maxv = (1LL << (40 -1)) - 1;
|
|
long long minv = (-1LL << (40 - 1));
|
|
C6X_COMPAT_LONG40 lres = orig_L40_set(src2);
|
|
|
|
lres = lres < 0 ? -lres : lres;
|
|
if (lres > maxv) lres = maxv;
|
|
else if (lres < minv) lres = minv;
|
|
|
|
return lres;
|
|
}
|
|
|
|
|
|
static inline C6X_COMPAT_LONG40 _ldotp2(int src1, int src2) {
|
|
return (C6X_COMPAT_LONG40) _dotp2(src1, src2);
|
|
}
|
|
|
|
|
|
static inline unsigned int _lmbd(unsigned int src1, unsigned int src2)
|
|
{
|
|
return norm_shift_amt_U_and_non_U(0,(((int) (src1 << 31)) >> 31) ^ (~src2));
|
|
}
|
|
|
|
|
|
static inline unsigned int _lnorm(C6X_COMPAT_LONG40 src2) {
|
|
if (src2 == 0)
|
|
return 39;
|
|
else {
|
|
int hi = (int)(src2 >> 32);
|
|
int lo = (int)src2;
|
|
|
|
|
|
long long temp = (unsigned long long)(unsigned)lo | (unsigned long long)hi << 32;
|
|
temp = orig_L40_set(temp);
|
|
|
|
if (temp == 0) return 0;
|
|
int cnt = 0;
|
|
while (((temp >> 39) & 1) == ((temp >> 38) & 1)) {
|
|
temp <<= 1;
|
|
cnt++;
|
|
}
|
|
return cnt;
|
|
}
|
|
}
|
|
|
|
|
|
static inline unsigned long long _lo(double src) {
|
|
unsigned long long v;
|
|
*(double*)&v = src;
|
|
return v;
|
|
}
|
|
|
|
|
|
static inline unsigned int _loll (long long src)
|
|
{
|
|
return (unsigned int) src;
|
|
}
|
|
|
|
|
|
static inline C6X_COMPAT_LONG40 _lsadd(int src1, C6X_COMPAT_LONG40 src2)
|
|
{
|
|
long long maxv = (1LL << (40 -1)) - 1;
|
|
long long minv = (-1LL << (40 - 1));
|
|
int hi = (int)(src2 >> 32);
|
|
int lo = (int)src2;
|
|
long long src2_int = (unsigned long long)(unsigned)lo | (unsigned long long)hi << 32;
|
|
|
|
|
|
long long src2_int2 = orig_L40_set(src2_int);
|
|
|
|
long long res = src1 + src2_int2;
|
|
|
|
if (res > maxv) {
|
|
res = maxv;
|
|
_overflow = 1;
|
|
}
|
|
else if (res < minv) {
|
|
res = minv;
|
|
_overflow = 1;
|
|
}
|
|
|
|
long long res2 = orig_L40_set(res);
|
|
|
|
res2 = (signed char)(res2 >> 32);
|
|
|
|
C6X_COMPAT_LONG40 lres = (((C6X_COMPAT_LONG40) res2) << 32) | ((unsigned int)res);
|
|
return lres;
|
|
}
|
|
|
|
|
|
|
|
static inline int _max2 (int src1, int src2) {
|
|
short s1[2], s2[2], r[2];
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r[0] = s1[0] > s2[0] ? s1[0] : s2[0];
|
|
r[1] = s1[1] > s2[1] ? s1[1] : s2[1];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline unsigned int _maxu4(unsigned int src1, unsigned int src2) {
|
|
unsigned int res0, res1, res2, res3;
|
|
unsigned int s1_0 = res0 = (src1 & 0xFF);
|
|
unsigned int s1_1 = res1 = (src1 & 0xFF00) >> 8;
|
|
unsigned int s1_2 = res2 = (src1 & 0xFF0000) >> 16;
|
|
unsigned int s1_3 = res3 = (src1 & 0xFF000000) >> 24;
|
|
|
|
unsigned int s2_0 = (src2 & 0xFF);
|
|
unsigned int s2_1 = (src2 & 0xFF00) >> 8;
|
|
unsigned int s2_2 = (src2 & 0xFF0000) >> 16;
|
|
unsigned int s2_3 = (src2 & 0xFF000000) >> 24;
|
|
|
|
// unsigned int res = 0;
|
|
|
|
if (s1_0 < s2_0)
|
|
res0 = s2_0;
|
|
|
|
if (s1_1 < s2_1)
|
|
res1 = s2_1;
|
|
|
|
if (s1_2 < s2_2)
|
|
res2 = s2_2;
|
|
|
|
if (s1_3 < s2_3)
|
|
res3 = s2_3;
|
|
|
|
return (res3 << 24) | (res2 << 16) | (res1 << 8) | res0;
|
|
|
|
|
|
}
|
|
|
|
static inline int _min2(int src1, int src2) {
|
|
short s1[2], s2[2], r[2];
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r[0] = s1[0] < s2[0] ? s1[0] : s2[0];
|
|
r[1] = s1[1] < s2[1] ? s1[1] : s2[1];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline unsigned int _minu4(unsigned int src1, unsigned int src2) {
|
|
unsigned int res0, res1, res2, res3;
|
|
unsigned int s1_0 = res0 = (src1 & 0xFF);
|
|
unsigned int s1_1 = res1 = (src1 & 0xFF00) >> 8;
|
|
unsigned int s1_2 = res2 = (src1 & 0xFF0000) >> 16;
|
|
unsigned int s1_3 = res3 = (src1 & 0xFF000000) >> 24;
|
|
|
|
unsigned int s2_0 = (src2 & 0xFF);
|
|
unsigned int s2_1 = (src2 & 0xFF00) >> 8;
|
|
unsigned int s2_2 = (src2 & 0xFF0000) >> 16;
|
|
unsigned int s2_3 = (src2 & 0xFF000000) >> 24;
|
|
|
|
// unsigned int res = 0;
|
|
|
|
if (s1_0 > s2_0)
|
|
res0 = s2_0;
|
|
|
|
if (s1_1 > s2_1)
|
|
res1 = s2_1;
|
|
|
|
if (s1_2 > s2_2)
|
|
res2 = s2_2;
|
|
|
|
if (s1_3 > s2_3)
|
|
res3 = s2_3;
|
|
|
|
return (res3 << 24) | (res2 << 16) | (res1 << 8) | res0;
|
|
}
|
|
|
|
|
|
static inline int _mpy(int src1, int src2) {
|
|
return (short) src1 * (short) src2;
|
|
}
|
|
|
|
|
|
static inline int _mpyh(int src1, int src2) {
|
|
return (short) (src1 >> 16) * (short) (src2 >> 16);
|
|
}
|
|
|
|
|
|
static inline long long _mpyhill (int src1, int src2)
|
|
{
|
|
short s1 = src1 >> 16;
|
|
return ((long long) src2) * s1;
|
|
}
|
|
|
|
static inline int _mpyhir(int src1, int src2)
|
|
{
|
|
short s1 = src1 >> 16;
|
|
long long result = ((long long) src2) * s1 + (1 << 14);
|
|
result >>= 15;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline int _mpyhl(int src1, int src2) {
|
|
return (short) (src1 >> 16) * (short) (src2);
|
|
}
|
|
|
|
static inline unsigned int _mpyhlu(unsigned int src1, unsigned int src2) {
|
|
return (unsigned short) (src1 >> 16) * (unsigned short) (src2);
|
|
}
|
|
|
|
static inline int _mpyhslu(int src1, unsigned int src2) {
|
|
return (short) (src1 >> 16) * (unsigned short) src2;
|
|
}
|
|
|
|
|
|
static inline int _mpyhsu(int src1, unsigned int src2) {
|
|
return (short) (src1 >>16) * (unsigned short) (src2 >>16);
|
|
}
|
|
|
|
|
|
static inline unsigned int _mpyhu(unsigned int src1, unsigned int src2) {
|
|
return (unsigned short) (src1 >>16) * (unsigned short) (src2 >> 16);
|
|
}
|
|
|
|
|
|
static inline int _mpyhuls(unsigned int src1, int src2) {
|
|
return (unsigned short) (src1 >>16) * (signed short) (src2);
|
|
}
|
|
|
|
|
|
static inline int _mpyhus(unsigned int src1, int src2) {
|
|
return (unsigned short) (src1 >> 16) * (short) (src2 >>16);
|
|
}
|
|
|
|
|
|
|
|
static inline long long _mpyidll (int src1, int src2)
|
|
{
|
|
return (long long) src1 * src2;
|
|
}
|
|
|
|
|
|
static inline int _mpylh(int src1, int src2) {
|
|
return (signed short) (src1 & 0xffff) * (signed short) (src2 >> 16);
|
|
}
|
|
|
|
static inline unsigned int _mpylhu(unsigned int src1, unsigned int src2) {
|
|
return (unsigned short) src1 * (unsigned short) (src2 >> 16);
|
|
}
|
|
|
|
|
|
static inline long long _mpylill (int src1, int src2)
|
|
{
|
|
return ((long long) src2) * ((short)src1);
|
|
}
|
|
|
|
|
|
|
|
static inline int _mpylir(int src1, int src2)
|
|
{
|
|
short s1 = src1;
|
|
long long result = ((long long) src2) * s1 + (1 << 14);
|
|
result >>= 15;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline int _mpylshu(int src1, unsigned int src2) {
|
|
return (short) src1 * (unsigned short) (src2 >> 16);
|
|
}
|
|
|
|
|
|
static inline int _mpyluhs(unsigned int src1, int src2) {
|
|
return (unsigned short) src1 * (short) (src2 >> 16);
|
|
}
|
|
|
|
|
|
|
|
static inline int _mpysu(int src1, unsigned int src2) {
|
|
return (short) src1 * (unsigned short) src2;
|
|
}
|
|
|
|
|
|
|
|
static inline long long _mpysu4ll (int src1, unsigned int src2) {
|
|
unsigned short res0, res1, res2, res3;
|
|
signed char s1_0 = (src1 & 0xff);
|
|
signed char s1_1 = (src1 & 0xff00) >> 8;
|
|
signed char s1_2 = (src1 & 0xff0000) >> 16;
|
|
signed char s1_3 = (src1 & 0xff000000) >> 24;
|
|
|
|
unsigned short s2_0 = (src2 & 0xff);
|
|
unsigned short s2_1 = (src2 & 0xff00) >> 8;
|
|
unsigned short s2_2 = (src2 & 0xff0000) >> 16;
|
|
unsigned short s2_3 = (src2 & 0xff000000) >> 24;
|
|
|
|
res0 = s1_0 * s2_0;
|
|
res1 = s1_1 * s2_1;
|
|
res2 = s1_2 * s2_2;
|
|
res3 = s1_3 * s2_3;
|
|
|
|
return (((unsigned long long) res3) << 48)
|
|
| (((unsigned long long) res2) << 32)
|
|
| (((unsigned long long) res1) << 16)
|
|
| res0;
|
|
}
|
|
|
|
static inline unsigned int _mpyu(unsigned int src1, unsigned int src2) {
|
|
unsigned v = (unsigned short)src1 * (unsigned short)src2;
|
|
return v;
|
|
}
|
|
|
|
static inline int _mpyus(unsigned int src1, int src2) {
|
|
return (unsigned short) src1 * (short) src2;
|
|
}
|
|
|
|
static inline long long _mpyu4ll (unsigned int src1, unsigned int src2) {
|
|
unsigned short res0, res1, res2, res3;
|
|
unsigned char s1_0 = (src1 & 0xff);
|
|
unsigned char s1_1 = (src1 & 0xff00) >> 8;
|
|
unsigned char s1_2 = (src1 & 0xff0000) >> 16;
|
|
unsigned char s1_3 = (src1 & 0xff000000) >> 24;
|
|
|
|
unsigned short s2_0 = (src2 & 0xff);
|
|
unsigned short s2_1 = (src2 & 0xff00) >> 8;
|
|
unsigned short s2_2 = (src2 & 0xff0000) >> 16;
|
|
unsigned short s2_3 = (src2 & 0xff000000) >> 24;
|
|
|
|
res0 = s1_0 * s2_0;
|
|
res1 = s1_1 * s2_1;
|
|
res2 = s1_2 * s2_2;
|
|
res3 = s1_3 * s2_3;
|
|
|
|
return (((unsigned long long) res3) << 48)
|
|
| (((unsigned long long) res2) << 32)
|
|
| (((unsigned long long) res1) << 16)
|
|
| res0;
|
|
}
|
|
|
|
|
|
static inline long long _mpy2ir(unsigned int src1, unsigned int src2)
|
|
{
|
|
if ((src1 == 0x8000) && (src2 == 0x80000000)) {
|
|
_overflow = 1;
|
|
return 0;
|
|
}
|
|
else {
|
|
short ls1 = src1 & 0xffff;
|
|
short hs1 = src1 >> 16;
|
|
unsigned long long hi = (((long long) hs1) * (int) src2 + (1 << 14)) >> 15;
|
|
unsigned long long lo = ((((long long) ls1) * (int) src2 + (1 << 14)) >> 15) & 0xFFFFFFFF;
|
|
return (hi << 32) | lo;
|
|
}
|
|
}
|
|
|
|
|
|
static inline long long _mpy2ll (int src1, int src2) {
|
|
short ls1 = src1 & 0xffff;
|
|
short hs1 = src1 >> 16;
|
|
short ls2 = src2 & 0xffff;
|
|
short hs2 = src2 >> 16;
|
|
|
|
unsigned long long hi = hs1 * hs2;
|
|
unsigned long long lo = (ls1 * ls2) & 0xFFFFFFFF;
|
|
|
|
return (hi << 32) | lo;
|
|
|
|
}
|
|
|
|
|
|
static inline int _mpy32(int src1, int src2)
|
|
{
|
|
return src1 * src2;
|
|
}
|
|
|
|
|
|
static inline long long _mpy32ll(int src1, int src2)
|
|
{
|
|
return ((long long) src1) * src2;
|
|
}
|
|
|
|
static inline long long _mpy32su(int src1, unsigned int src2)
|
|
{
|
|
return ((long long) src1) * ((int) src2);
|
|
}
|
|
|
|
static inline long long _mpy32u(unsigned int src1, unsigned int src2)
|
|
{
|
|
return ((long long) ((int) src1)) * ((long long) ((int) src2));
|
|
}
|
|
|
|
static inline long long _mpy32us(unsigned int src1, int src2)
|
|
{
|
|
return ((int) src1) * ((long long) src2);
|
|
}
|
|
|
|
static inline int _mvd (int src2)
|
|
{
|
|
return src2;
|
|
}
|
|
|
|
|
|
static inline unsigned int _norm(int src2)
|
|
{
|
|
return norm_shift_amt_U_and_non_U(1,src2);
|
|
}
|
|
|
|
|
|
static inline unsigned int _pack2 (unsigned int src1, unsigned int src2) {
|
|
short s1[2], s2[2], r[2];
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r[0] = s2[0];
|
|
r[1] = s1[0];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline int _packh2 (unsigned int src1, unsigned int src2) {
|
|
unsigned v0 = src1 & 0xffff0000;
|
|
unsigned v1 = src2 >> 16;
|
|
unsigned v = v0|v1;
|
|
return v;
|
|
|
|
}
|
|
|
|
static inline unsigned int _packh4 (unsigned int src1, unsigned int src2) {
|
|
unsigned v3 = (src1 >> 24) & 0xff;
|
|
unsigned v2 = (src1 >> 8) & 0xff;
|
|
unsigned v1 = (src2 >> 24) & 0xff;
|
|
unsigned v0 = (src2 >> 8) & 0xff;
|
|
unsigned v = (v3<<24) | (v2<<16) | (v1 << 8) | v0;
|
|
return v;
|
|
}
|
|
|
|
static inline unsigned int _packhl2 (unsigned int src1, unsigned int src2) {
|
|
unsigned v0 = src1 & 0xffff0000;
|
|
unsigned v1 = src2 & 0x0000ffff;
|
|
unsigned v = v0|v1;
|
|
return v;
|
|
}
|
|
|
|
static inline unsigned int _packlh2 (unsigned int src1, unsigned int src2) {
|
|
unsigned v0 = src1 << 16;
|
|
unsigned v1 = (src2 >> 16) & 0xffff;
|
|
unsigned v = v0|v1;
|
|
return v;
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned int _packl4 (unsigned int src1, unsigned int src2) {
|
|
unsigned v3 = (src1 >> 16) & 0xff;
|
|
unsigned v2 = (src1) & 0xff;
|
|
unsigned v1 = (src2 >> 16) & 0xff;
|
|
unsigned v0 = (src2) & 0xff;
|
|
unsigned v = (v3<<24) | (v2<<16) | (v1 << 8) | v0;
|
|
return v;
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned int _rpack2 (unsigned int src1, unsigned int src2) {
|
|
int s1 = (int) src1;
|
|
int s2 = (int) src2;
|
|
s1 = util_shift_right_saturate_n (s1, -1, 32);
|
|
s2 = util_shift_right_saturate_n (s2, -1, 32);
|
|
return (unsigned int) (s1 & 0xffff0000) | (unsigned int) ((s2 & 0xffff0000) >>16);
|
|
}
|
|
|
|
|
|
static inline unsigned int _rotl (unsigned int src1, unsigned int src2)
|
|
{
|
|
src2 &= 0x1f;
|
|
return (src1 << src2) | (src1 >> (32 - src2));
|
|
}
|
|
|
|
|
|
static inline int _sadd(int src1, int src2) {
|
|
signed long long res;
|
|
signed long long maxv, minv;
|
|
maxv = (1LL << (32-1)) - 1;
|
|
minv = (-1LL << (32-1));
|
|
res = (long long) src1 + (long long) src2;
|
|
if (res > maxv) {
|
|
res = maxv;
|
|
_overflow = 1;
|
|
}
|
|
else if (res < minv ) {
|
|
res = minv;
|
|
_overflow = 1;
|
|
}
|
|
return (int) res;
|
|
}
|
|
|
|
static inline long long _saddsub(unsigned int src1, unsigned int src2) {
|
|
int radd;
|
|
signed long long rsub;
|
|
|
|
signed long long maxv, minv;
|
|
maxv = (1LL << (32-1)) - 1;
|
|
minv = (-1LL << (32-1));
|
|
|
|
radd = (int) src1 + (int) src2;
|
|
|
|
// saturate on subtract, not add
|
|
|
|
|
|
rsub = (long long) ((int) src1) - (long long) ((int) src2);
|
|
if (rsub > maxv) {
|
|
rsub = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (rsub < minv ) {
|
|
rsub = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
return (((unsigned long long) radd) << 32) | ( rsub & 0x00000000ffffffff ) ;
|
|
}
|
|
|
|
|
|
|
|
static inline long long _saddsub2(unsigned int src1, unsigned int src2) {
|
|
signed int radd[2];
|
|
signed int rsub[2];
|
|
signed short s1[2], s2[2];
|
|
|
|
signed int maxv, minv;
|
|
maxv = (1L << (16-1)) - 1;
|
|
minv = (-1L << (16-1));
|
|
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
|
|
radd[0] = (int) s1[0] + (int) s2[0];
|
|
radd[1] = (int) s1[1] + (int) s2[1];
|
|
|
|
rsub[0] = (int) s1[0] - (int) s2[0];
|
|
rsub[1] = (int) s1[1] - (int) s2[1];
|
|
|
|
if (radd[0] > maxv) {
|
|
radd[0] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (radd[0] < minv ) {
|
|
radd[0] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
if (radd[1] > maxv) {
|
|
radd[1] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (radd[1] < minv ) {
|
|
radd[1] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
|
|
if (rsub[0] > maxv) {
|
|
rsub[0] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (rsub[0] < minv ) {
|
|
rsub[0] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
if (rsub[1] > maxv) {
|
|
rsub[1] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (rsub[1] < minv ) {
|
|
rsub[1] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
|
|
return ((((unsigned long long) radd[1]) & 0x000000000000ffff) << 48) |
|
|
((((unsigned long long) radd[0]) & 0x000000000000ffff) << 32) |
|
|
((((unsigned long long) rsub[1]) & 0x000000000000ffff) << 16) |
|
|
((((unsigned long long) rsub[0]) & 0x000000000000ffff));
|
|
}
|
|
|
|
|
|
|
|
static inline int _sadd2(int src1, int src2) {
|
|
signed short s1[2], s2[2];
|
|
signed int r[2], maxv, minv;
|
|
|
|
maxv = (1L << (16-1)) - 1;
|
|
minv = (-1L << (16-1));
|
|
|
|
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
|
|
r[0] = (int) s1[0] + (int) s2[0];
|
|
r[1] = (int) s1[1] + (int) s2[1];
|
|
|
|
if (r[0] > maxv) {
|
|
r[0] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (r[0] < minv ) {
|
|
r[0] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
if (r[1] > maxv) {
|
|
r[1] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (r[1] < minv ) {
|
|
r[1] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
return ((r[1] & 0xffff) << 16 ) | (r[0] & 0xffff) ;
|
|
}
|
|
|
|
|
|
static inline int _saddus2(unsigned int src1, int src2) {
|
|
int res0, res1;
|
|
unsigned int s1_0 = (src1 & 0xffff);
|
|
unsigned int s1_1 = (src1 & 0xffff0000) >> 16;
|
|
|
|
short s2_0 = (src2 & 0xffff);
|
|
short s2_1 = (src2 & 0xffff0000) >> 16;
|
|
|
|
res0 = s1_0 + s2_0;
|
|
res1 = s1_1 + s2_1;
|
|
|
|
if (res0 >= 0x10000)
|
|
res0 = 0xffff;
|
|
else if (res0 < 0)
|
|
res0 = 0;
|
|
|
|
if (res1 >= 0x10000)
|
|
res1 = 0xffff;
|
|
else if (res1 < 0)
|
|
res1 = 0;
|
|
|
|
return (res1 << 16) | res0;
|
|
}
|
|
|
|
|
|
static inline unsigned int _saddu4(unsigned int src1, unsigned int src2) {
|
|
unsigned int res0, res1, res2, res3;
|
|
unsigned int s1_0 = (src1 & 0xff);
|
|
unsigned int s1_1 = (src1 & 0xff00) >> 8;
|
|
unsigned int s1_2 = (src1 & 0xff0000) >> 16;
|
|
unsigned int s1_3 = (src1 & 0xff000000) >> 24;
|
|
|
|
unsigned int s2_0 = (src2 & 0xff);
|
|
unsigned int s2_1 = (src2 & 0xff00) >> 8;
|
|
unsigned int s2_2 = (src2 & 0xff0000) >> 16;
|
|
unsigned int s2_3 = (src2 & 0xff000000) >> 24;
|
|
|
|
res0 = s1_0 + s2_0;
|
|
res1 = s1_1 + s2_1;
|
|
res2 = s1_2 + s2_2;
|
|
res3 = s1_3 + s2_3;
|
|
|
|
if (res0 >= 0x100)
|
|
res0 = 0xff;
|
|
|
|
if (res1 >= 0x100)
|
|
res1 = 0xff;
|
|
|
|
if (res2 >= 0x100)
|
|
res2 = 0xff;
|
|
|
|
if (res3 >= 0x100)
|
|
res3 = 0xff;
|
|
|
|
return (res3 << 24) | (res2 << 16) | (res1 << 8) | res0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int _sat(C6X_COMPAT_LONG40 src2)
|
|
{
|
|
long long maxv = (1LL << (32-1)) - 1;
|
|
long long minv = (-1LL << (32-1));
|
|
|
|
int hi = (int)(src2 >> 32);
|
|
int lo = (int)src2;
|
|
long long temp = (unsigned long long)(unsigned)lo | (unsigned long long)hi << 32;
|
|
temp = orig_L40_set(temp);
|
|
|
|
if (temp > maxv) {
|
|
temp = maxv;
|
|
_overflow = 1;
|
|
}
|
|
else if (temp < minv) {
|
|
temp = minv;
|
|
_overflow = 1;
|
|
}
|
|
return (int) temp;
|
|
}
|
|
|
|
static inline unsigned int _set(unsigned int src2, unsigned int csta, unsigned int cstb)
|
|
{
|
|
csta &= 0x1f;
|
|
cstb &= 0x1f;
|
|
if (csta > cstb)
|
|
return src2;
|
|
else {
|
|
unsigned int mask = (((1 << (cstb - csta)) << 1) - 1) << csta;
|
|
return src2 | mask;
|
|
}
|
|
}
|
|
|
|
static inline unsigned int _setr(unsigned int src2, int src1)
|
|
{
|
|
unsigned int csta = (src1 >> 5) & 0x1f;
|
|
unsigned int cstb = src1 & 0x1f;
|
|
if (csta > cstb)
|
|
return src2;
|
|
else {
|
|
unsigned int mask = (((1 << (cstb - csta)) << 1) - 1) << csta;
|
|
return src2 | mask;
|
|
}
|
|
}
|
|
|
|
|
|
static inline unsigned int _shfl (unsigned int src2)
|
|
{
|
|
unsigned short lo = src2;
|
|
unsigned short hi = src2 >> 16;
|
|
unsigned int result = 0;
|
|
int i;
|
|
for (i = 0; i < 32; i+= 2) {
|
|
result >>= 1;
|
|
result |= (lo & 0x1) << 31;
|
|
lo >>= 1;
|
|
result >>= 1;
|
|
result |= (hi & 0x1) << 31;
|
|
hi >>= 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static inline long long _shfl3 (unsigned int src1, unsigned int src2)
|
|
{
|
|
unsigned short lo = src2;
|
|
unsigned short hi = src1 >> 16;
|
|
unsigned short mid = src1;
|
|
unsigned long long result = 0;
|
|
int i;
|
|
for (i = 0; i < 32; i+= 2) {
|
|
result >>= 1;
|
|
result |= ((unsigned long long) (lo & 0x1)) << 47;
|
|
lo >>= 1;
|
|
result >>= 1;
|
|
result |= ((unsigned long long) (mid & 0x1)) << 47;
|
|
mid >>= 1;
|
|
result >>= 1;
|
|
result |= ((unsigned long long) (hi & 0x1)) << 47;
|
|
hi >>= 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int _shlmb (unsigned int src1, unsigned int src2)
|
|
{
|
|
return (src2 << 8) | (src1 >> 24);
|
|
}
|
|
|
|
static inline unsigned int _shrmb (unsigned int src1, unsigned int src2)
|
|
{
|
|
return (src2 >> 8) | (src1 << 24);
|
|
}
|
|
|
|
|
|
static inline unsigned int _shru2 (unsigned int src1, unsigned int src2) {
|
|
unsigned short hs1 = src1 >> 16;
|
|
unsigned short ls1 = src1 & 0xFFFF;
|
|
hs1 >>= src2;
|
|
ls1 >>= src2;
|
|
return (hs1 << 16) | ls1;
|
|
}
|
|
|
|
|
|
static inline int _shr2 (int src1, unsigned int src2) {
|
|
short s1[2], result[2];
|
|
*((int*)s1) = src1;
|
|
src2 = src2 & 31;
|
|
result[0] = (int)s1[0] >> src2;
|
|
result[1] = (int)s1[1] >> src2;
|
|
|
|
return *(int*)result;
|
|
}
|
|
|
|
|
|
static inline int _smpy (int src1, int src2) {
|
|
unsigned long long result;
|
|
result = (((short) src1 * (short) src2) << 1);
|
|
|
|
if ((result & 0xffffffff) == 0x80000000){
|
|
result = 0x7fffffff;
|
|
_overflow = 1;
|
|
}
|
|
return (int) (result);
|
|
}
|
|
|
|
static inline int _smpyh (int src1, int src2) {
|
|
unsigned long long result;
|
|
result = ((short) (src1 >> 16) * (short) (src2 >> 16)) << 1;
|
|
if ((result & 0xffffffff) == 0x80000000){
|
|
result = 0x7fffffff;
|
|
_overflow = 1;
|
|
}
|
|
return (int) (result);
|
|
}
|
|
|
|
static inline int _smpyhl (int src1, int src2) {
|
|
unsigned long long result;
|
|
result = ((short) (src1 >> 16) * (short) (src2)) << 1;
|
|
if ((result & 0xffffffff) == 0x80000000){
|
|
result = 0x7fffffff;
|
|
_overflow = 1;
|
|
}
|
|
return (int) (result);
|
|
}
|
|
|
|
static inline int _smpylh (int src1, int src2) {
|
|
unsigned long long result;
|
|
result = ((short) (src1) * (short) (src2 >> 16)) << 1;
|
|
if ((result & 0xffffffff) == 0x80000000){
|
|
result = 0x7fffffff;
|
|
_overflow = 1;
|
|
}
|
|
return (int) (result);
|
|
}
|
|
|
|
static inline long long _smpy2ll (int src1, int src2) {
|
|
short ls1 = src1 & 0XFFFF;
|
|
short hs1 = src1 >> 16;
|
|
short ls2 = src2 & 0XFFFF;
|
|
short hs2 = src2 >> 16;
|
|
|
|
unsigned long long hi = (hs1 * hs2) << 1;
|
|
unsigned long long lo = ((ls1 * ls2) << 1) & 0xFFFFFFFF;
|
|
if ((hi & 0xffffffff) == 0x80000000){
|
|
hi = 0x7fffffff;
|
|
_overflow = 1;
|
|
}
|
|
|
|
if ((lo & 0xffffffff) == 0x80000000){
|
|
lo = 0x7fffffff;
|
|
_overflow = 1;
|
|
}
|
|
|
|
return (hi << 32) | lo;
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int _smpy32(int src1, int src2)
|
|
{
|
|
long long res = (long long) src1 * src2;
|
|
res <<= 1;
|
|
res >>= 32;
|
|
return res;
|
|
}
|
|
|
|
static inline unsigned char TEN_satu8 (short src)
|
|
{
|
|
if (src > 0xff)
|
|
return 0xff;
|
|
else if (src < 0)
|
|
return 0;
|
|
else
|
|
return src;
|
|
}
|
|
|
|
static inline int _spack2 (int src1, int src2) {
|
|
short s1 = (short) util_saturate_n_no_state(src1,16);
|
|
short s2 = (short) util_saturate_n_no_state(src2,16);
|
|
return ( (unsigned int) s1 << 16) | (((int) s2) & 0xFFFF);
|
|
}
|
|
|
|
|
|
static inline unsigned int _spacku4 (int src1, int src2) {
|
|
short lolo = src2;
|
|
short lohi = src2 >> 16;
|
|
short hilo = src1;
|
|
short hihi = src1 >> 16;
|
|
|
|
lolo = TEN_satu8(lolo);
|
|
lohi = TEN_satu8(lohi);
|
|
hilo = TEN_satu8(hilo);
|
|
hihi = TEN_satu8(hihi);
|
|
|
|
return (((unsigned int) hihi) << 24) | (((unsigned int) hilo) << 16) | (lohi << 8) | lolo;
|
|
}
|
|
|
|
|
|
|
|
static inline int _sshl (int src1, unsigned int src2) {
|
|
short local2 = (short)(src2 & 0x7FFF);
|
|
return (int) util_shift_right_saturate_n(src1, -local2, 32);
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int _sshvl (int src2, int src1) {
|
|
short s1;
|
|
if (src1 > 31)
|
|
s1 = 31;
|
|
else if (src1 < -31)
|
|
s1 = -31;
|
|
else
|
|
s1 = src1;
|
|
|
|
return (int) util_shift_right_saturate_n(src2, -s1, 32);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline int _sshvr (int src2, int src1) {
|
|
short s1;
|
|
if (src1 > 31)
|
|
s1 = 31;
|
|
else if (src1 < -31)
|
|
s1 = -31;
|
|
else
|
|
s1 = src1;
|
|
return (int) util_shift_right_saturate_n(src2, s1, 32);
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int _ssub(int src1, int src2) {
|
|
signed long long res;
|
|
signed long long maxv, minv;
|
|
maxv = (1LL << (32-1)) - 1;
|
|
minv = (-1LL << (32-1));
|
|
res = (long long) src1 - (long long) src2;
|
|
if (res > maxv) {
|
|
res = maxv;
|
|
_overflow = 1;
|
|
}
|
|
else if (res < minv ) {
|
|
res = minv;
|
|
_overflow = 1;
|
|
}
|
|
return (int) res;
|
|
}
|
|
|
|
static inline int _ssub2(int src1, int src2) {
|
|
signed short s1[2], s2[2];
|
|
signed int r[2], maxv, minv;
|
|
|
|
maxv = (1L << (16-1)) - 1;
|
|
minv = (-1L << (16-1));
|
|
|
|
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
|
|
r[0] = (int) s1[0] - (int) s2[0];
|
|
r[1] = (int) s1[1] - (int) s2[1];
|
|
|
|
if (r[0] > maxv) {
|
|
r[0] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (r[0] < minv ) {
|
|
r[0] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
if (r[1] > maxv) {
|
|
r[1] = maxv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
else if (r[1] < minv ) {
|
|
r[1] = minv;
|
|
/* NOTE: TI c6x does NOT set the overflow register even if results saturate */
|
|
/* _overflow = 1; */
|
|
}
|
|
|
|
return ((r[1] & 0xffff) << 16 ) | (r[0] & 0xffff) ;
|
|
}
|
|
|
|
|
|
static inline int _subabs4 (int src1, int src2) {
|
|
int res0, res1, res2, res3;
|
|
unsigned int s1_0 = (src1 & 0xff);
|
|
unsigned int s1_1 = (src1 & 0xff00) >> 8;
|
|
unsigned int s1_2 = (src1 & 0xff0000) >> 16;
|
|
unsigned int s1_3 = (src1 & 0xff000000) >> 24;
|
|
|
|
unsigned int s2_0 = (src2 & 0xff);
|
|
unsigned int s2_1 = (src2 & 0xff00) >> 8;
|
|
unsigned int s2_2 = (src2 & 0xff0000) >> 16;
|
|
unsigned int s2_3 = (src2 & 0xff000000) >> 24;
|
|
|
|
res0 = s1_0 - s2_0;
|
|
res1 = s1_1 - s2_1;
|
|
res2 = s1_2 - s2_2;
|
|
res3 = s1_3 - s2_3;
|
|
|
|
if (res0 < 0)
|
|
res0 = -res0;
|
|
|
|
if (res1 < 0)
|
|
res1 = -res1;
|
|
|
|
if (res2 < 0)
|
|
res2 = -res2;
|
|
|
|
if (res3 < 0)
|
|
res3 = -res3;
|
|
|
|
return (res3 << 24) | (res2 << 16) | (res1 << 8) | res0;
|
|
}
|
|
|
|
|
|
static inline unsigned int _subc (unsigned int src1, unsigned int src2)
|
|
{
|
|
if ( src1 >= src2)
|
|
return ((src1 - src2) << 1) + 1;
|
|
else
|
|
return src1 << 1;
|
|
}
|
|
|
|
|
|
|
|
static inline int _sub2(int src1, int src2) {
|
|
short s1[2], s2[2], r[2];
|
|
int result;
|
|
*((int*)s1) = src1;
|
|
*((int*)s2) = src2;
|
|
r[0] = s1[0] - s2[0];
|
|
r[1] = s1[1] - s2[1];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline int _sub4(int src1, int src2) {
|
|
char c1[4], c2[4], r[4];
|
|
int result;
|
|
*((int*)c1) = src1;
|
|
*((int*)c2) = src2;
|
|
r[0] = c1[0] - c2[0];
|
|
r[1] = c1[1] - c2[1];
|
|
r[2] = c1[2] - c2[2];
|
|
r[3] = c1[3] - c2[3];
|
|
result = *(int*)r;
|
|
return result;
|
|
}
|
|
|
|
|
|
static inline int _swap4 (unsigned int src1) {
|
|
unsigned char v0 = src1;
|
|
unsigned char v1 = src1 >> 8;
|
|
unsigned char v2 = src1 >> 16;
|
|
unsigned char v3 = src1 >> 24;
|
|
unsigned v = v0<<8 | v1 | v2<<24 | v3<<16;
|
|
return v;
|
|
}
|
|
|
|
static inline unsigned int _unpkhu4 (unsigned int src1) {
|
|
unsigned v0 = src1>>24;
|
|
unsigned v1 = (src1>>16) & 0xff;
|
|
return (v0<<16) | v1;
|
|
}
|
|
|
|
static inline unsigned int _unpklu4 (unsigned int src1) {
|
|
unsigned v1 = (src1>>8) & 0xff;
|
|
unsigned v0 = (src1) & 0xff;
|
|
return (v1<<16) | v0;
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline unsigned int _xpnd2 (unsigned int src1) {
|
|
int v0 = (src1 & 0x1) ? 0x0000ffff : 0x00000000;
|
|
int v1 = (src1 & 0x2) ? 0xffff0000 : 0x00000000;
|
|
return v0|v1;
|
|
}
|
|
|
|
static inline unsigned int _xpnd4 (unsigned int src1) {
|
|
int v0 = (src1 & 0x1) ? 0x000000ff : 0x00000000;
|
|
int v1 = (src1 & 0x2) ? 0x0000ff00 : 0x00000000;
|
|
int v2 = (src1 & 0x4) ? 0x00ff0000 : 0x00000000;
|
|
int v3 = (src1 & 0x8) ? 0xff000000 : 0x00000000;
|
|
int r = v0|v1|v2|v3;
|
|
return r;
|
|
}
|
|
|
|
|
|
|
|
// end of Implemented in alphabetical order
|
|
|
|
|
|
#endif /* __C6X_COMPAT__H */
|