 |
Runtime
Version 1.0
PULP Kernel Library
|
 |
Functions | |
| v2s | __builtin_pulp_pack2 (short int x, short int y) |
| Pack 2 short int into a vector. More... | |
| v4s | __builtin_pulp_pack4 (char x, char y, char z, char t) |
| Pack 4 bytes into a vector. More... | |
| v2s | __builtin_pulp_shuffleh (v2s x, v2s mask) |
| Permutes vector elements of x according to positions given in mask (a vector). More... | |
| v4s | __builtin_pulp_shuffleb (v4s x, v4s mask) |
| Permutes vector elements of x according to positions given in mask (a vector). More... | |
| v2s | __builtin_pulp_shuffle2h (v2s x, v2s y, v2s mask) |
| Picks 2 elements from vectors (x, y) according to positions given in mask (a vector). More... | |
| v4s | __builtin_pulp_shuffle4b (v4s x, v4s y, v4s mask) |
| Picks 4 elements from vectors (x, y) according to positions given in mask (a vector). More... | |
| v2u | __builtin_pulp_abs2 (v2s x) |
| Element wise abs on a vector of 2 shorts. More... | |
| v4u | __builtin_pulp_abs4 (v4s x) |
| Element wise abs on a vector of 4 bytes. More... | |
| v2u | __builtin_pulp_neg2 (v2s x) |
| Element wise unary minus on a vector of 2 shorts. More... | |
| v4u | __builtin_pulp_neg4 (v4s x) |
| Element wise unary minus on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_add2 (v2s x, v2s y) |
| Element wise addition on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_add4 (v4s x, v4s y) |
| Element wise addition on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_sub2 (v2s x, v2s y) |
| Element wise substraction on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_sub4 (v4s x, v4s y) |
| Element wise substraction on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_avg2 (v2s x, v2s y) |
| Element wise average on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_avg4 (v4s x, v4s y) |
| Element wise average on a vector of 4 bytes. More... | |
| v2u | __builtin_pulp_avgu2 (v2s x, v2s y) |
| Element wise average on a vector of 2 shorts. More... | |
| v4u | __builtin_pulp_avgu4 (v4s x, v4s y) |
| Element wise unsigned average on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_min2 (v2s x, v2s y) |
| Element wise min on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_min4 (v4s x, v4s y) |
| Element wise min on a vector of 4 bytes. More... | |
| v2u | __builtin_pulp_minu2 (v2s x, v2s y) |
| Element wise unsigned min on a vector of 2 shorts. More... | |
| v4u | __builtin_pulp_minu4 (v4s x, v4s y) |
| Element wise unsigned min on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_max2 (v2s x, v2s y) |
| Element wise max on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_max4 (v4s x, v4s y) |
| Element wise max on a vector of 4 bytes. More... | |
| v2u | __builtin_pulp_maxu2 (v2s x, v2s y) |
| Element wise unsigned max on a vector of 2 shorts. More... | |
| v4u | __builtin_pulp_maxu4 (v4s x, v4s y) |
| Element wise unsigned max on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_and2 (v2s x, v2s y) |
| Element wise bitwise and on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_and4 (v4s x, v4s y) |
| Element wise bitwise and on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_or2 (v2s x, v2s y) |
| Element wise bitwise or on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_or4 (v4s x, v4s y) |
| Element wise bitwise or on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_exor2 (v2s x, v2s y) |
| Element wise bitwise exor on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_exor4 (v4s x, v4s y) |
| Element wise bitwise exor on a vector of 4 bytes. More... | |
| v2u | __builtin_pulp_srl2 (v2s x, v2s y) |
| Element wise logical shift right on a vector of 2 shorts. More... | |
| v4u | __builtin_pulp_srl4 (v4s x, v4s y) |
| Element wise logical shift right on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_sra2 (v2s x, v2s y) |
| Element wise arithmetic shift right on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_sra4 (v4s x, v4s y) |
| Element wise arithmetic shift right on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_sll2 (v2s x, v2s y) |
| Element wise logical shift left on a vector of 2 shorts. More... | |
| v4s | __builtin_pulp_sll4 (v4s x, v4s y) |
| Element wise logical shift left on a vector of 4 bytes. More... | |
| v2s | __builtin_pulp_add2div2 (v2s x, v2s y) |
| Element wise addition on a vector of 2 shorts followed by a division by 2. More... | |
| v2s | __builtin_pulp_add2div4 (v2s x, v2s y) |
| Element wise addition on a vector of 2 shorts followed by a division by 4. More... | |
| v2s | __builtin_pulp_sub2div2 (v2s x, v2s y) |
| Element wise substraction on a vector of 2 shorts followed by a division by 2. More... | |
| v2s | __builtin_pulp_sub2div4 (v2s x, v2s y) |
| Element wise substraction on a vector of 2 shorts followed by a division by 4. More... | |
| v4s | __builtin_pulp_add4div2 (v4s x, v4s y) |
| Element wise addition on a vector of 4 bytes followed by a division by 2. More... | |
| v4s | __builtin_pulp_add4div4 (v4s x, v4s y) |
| Element wise addition on a vector of 4 bytes followed by a division by 4. More... | |
| v4s | __builtin_pulp_sub4div2 (v4s x, v4s y) |
| Element wise substraction on a vector of 4 bytes followed by a division by 2. More... | |
| v4s | __builtin_pulp_sub4div4 (v4s x, v4s y) |
| Element wise substraction on a vector of 4 bytes followed by a division by 4. More... | |
| v2u __builtin_pulp_abs2 | ( | v2s | x | ) |
Element wise abs on a vector of 2 shorts.
Returns (v2u) {((x)[0]<0)?-(x)[0]:(x)[0], ((x)[1]<0)?-(x)[1]:(x)[1]}
Available macros:
gap8_abs2(x)
__ABS2(x) | x | A vector of 2 shorts |
Referenced by __ABS2(), and gap8_abs2().
| v4u __builtin_pulp_abs4 | ( | v4s | x | ) |
Element wise abs on a vector of 4 bytes.
Returns (v4u) {((x)[0]<0)?-(x)[0]:(x)[0], ((x)[1]<0)?-(x)[1]:(x)[1], ((x)[2]<0)?-(x)[2]:(x)[2], ((x)[3]<0)?-(x)[3]:(x)[3]}
Available macros:
gap8_abs4(x)
__ABS4(x) | x | A vector of 4 bytes |
Referenced by __ABS4(), and gap8_abs4().
| v2s __builtin_pulp_add2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise addition on a vector of shorts.
Returns (v2s) {(x)[0]+(y)[0], (x)[1]+(y)[1]}
Available macros:
gap8_add2(x, y)
__ADD2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __ADD2(), and gap8_add2().
| v2s __builtin_pulp_add2div2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise addition on a vector of 2 shorts followed by a division by 2.
Returns ((x)+(y))>>(v2s) {1, 1}
Available macros:
gap8_add2div2(x, y)
__ADD2DIV2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __ADD2DIV2(), and gap8_add2div2().
| v2s __builtin_pulp_add2div4 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise addition on a vector of 2 shorts followed by a division by 4.
Returns ((x)+(y))>>(v2s) {2, 2}
Available macros:
gap8_add2div4(x, y)
__ADD2DIV4(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __ADD2DIV4(), and gap8_add2div4().
| v4s __builtin_pulp_add4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise addition on a vector of 4 bytes.
Returns (v4s) {(x)[0]+(y)[0], (x)[1]+(y)[1], (x)[2]+(y)[2], (x)[3]+(y)[3]}
Available macros:
gap8_add4(x, y)
__ADD4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __ADD4(), and gap8_add4().
| v4s __builtin_pulp_add4div2 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise addition on a vector of 4 bytes followed by a division by 2.
Returns ((x)+(y))>>(v2s) {1, 1}
Available macros:
gap8_add4div2(x, y)
__ADD4DIV2(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __ADD4DIV2(), and gap8_add4div2().
| v4s __builtin_pulp_add4div4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise addition on a vector of 4 bytes followed by a division by 4.
Returns ((x)+(y))>>(v2s) {2, 2}
Available macros:
gap8_add4div4(x, y)
__ADD4DIV4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __ADD4DIV4(), and gap8_add4div4().
| v2s __builtin_pulp_and2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise bitwise and on a vector of 2 shorts.
Returns (v2s) {(x)[0]&(y)[0], (x)[1]&(y)[1]}
Available macros:
gap8_and2(x, y)
__AND2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __AND2(), and gap8_and2().
| v4s __builtin_pulp_and4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise bitwise and on a vector of 4 bytes.
Returns (v4s) {(x)[0]&(y)[0], (x)[1]&(y)[1], (x)[2]&(y)[2], (x)[3]&(y)[3]}
Available macros:
gap8_and4(x, y)
__AND4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __AND4(), and gap8_and4().
| v2s __builtin_pulp_avg2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise average on a vector of 2 shorts.
Returns (v2s) {((x)[0]+(y)[0]))>>1, ((x)[1]+(y)[1])>>1}; Addition is performed on 16 bits.
Available macros:
gap8_avg2(x, y)
__AVG2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __AVG2(), and gap8_avg2().
| v4s __builtin_pulp_avg4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise average on a vector of 4 bytes.
Returns (v2s) ((v4s) {((x)[0]+(y)[0])>>1, ((x)[1]+(y)[1])>>1, ((x)[2]+(y)[2])>>1, ((x)[3]+(y)[3])>>1}. Addition is performed on 8 bits.
Available macros:
gap8_avg4(x, y)
__AVG4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __AVG4(), and gap8_avg4().
| v2u __builtin_pulp_avgu2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise average on a vector of 2 shorts.
Returns (v2u) {((unsigned short)(x)[0]+(unsigned short)(y)[0])>>1, ((unsigned short)(x)[1]+(unsigned short)(y)[1])>>1}; Addition is performed on 16 bits.
Available macros:
gap8_avgu2(x, y)
__AVGU2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __AVGU2(), and gap8_avgu2().
| v4u __builtin_pulp_avgu4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise unsigned average on a vector of 4 bytes.
Returns (v4u) {((unsigned char)(x)[0]+(unsigned char)(y)[0])>>1, ((unsigned char)(x)[1]+(unsigned char)(y)[1])>>1, ((unsigned char)(x)[2]+(unsigned char)(y)[2])>>1, ((unsigned char)(x)[3]+(unsigned char)(y)[3])>>1}; Addition is perfomed on 8 bits.
Available macros:
gap8_avgu4(x, y)
__AVGU4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __AVGU4(), and gap8_avgu4().
| v2s __builtin_pulp_exor2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise bitwise exor on a vector of 2 shorts.
Returns (v2s) {(x)[0]^(y)[0], (x)[1]^(y)[1]}
Available macros:
gap8_exor2(x, y)
__EXOR2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __EXOR2(), and gap8_exor2().
| v4s __builtin_pulp_exor4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise bitwise exor on a vector of 4 bytes.
Returns (v4s) {(x)[0]^(y)[0], (x)[1]^(y)[1], (x)[2]^(y)[2], (x)[3]^(y)[3]}
Available macros:
gap8_exor4(x, y)
__EXOR4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __EXOR4(), and gap8_exor4().
| v2s __builtin_pulp_max2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise max on a vector of 2 shorts.
Returns (v2s) {((signed short)(x)[0]>(signed short)(y)[0])?((signed short)(x)[0]):((signed short)(y)[0]), ((signed short)(x)[1]>(signed short)(y)[1])?((signed short)(x)[1]):((signed short)(y)[1])}
Available macros:
gap8_max2(x, y)
__MAX2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __MAX2(), and gap8_max2().
| v4s __builtin_pulp_max4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise max on a vector of 4 bytes.
Returns (v4s) {((signed char)(x)[0]>(signed char)(y)[0])?(signed char)(x)[0]:(signed char)(y)[0], ((signed char)(x)[1]>(signed char)(y)[1])?(signed char)(x)[1]:(signed char)(y)[1], ((signed char)(x)[2]>(signed char)(y)[2])?(signed char)(x)[2]:(signed char)(y)[2], ((signed char)(x)[3]>(signed char)(y)[3])?(signed char)(x)[3]:(signed char)(y)[3]}
Available macros:
gap8_max4(x, y)
__MAX4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __MAX4(), and gap8_max4().
| v2u __builtin_pulp_maxu2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise unsigned max on a vector of 2 shorts.
Returns (v2u) {((unsigned short)(x)[0]>(unsigned short)(y)[0])?(unsigned short)(x)[0]:(unsigned short)(y)[0], ((unsigned short)(x)[1]>(unsigned short)(y)[1])?(unsigned short)(x)[1]:(unsigned short)(y)[1]}
Available macros:
gap8_maxu2(x, y)
__MAXU2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __MAXU2(), and gap8_maxu2().
| v4u __builtin_pulp_maxu4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise unsigned max on a vector of 4 bytes.
Returns (v4u) {((unsigned char)(x)[0]>(unsigned char)(y)[0])?(unsigned char)(x)[0]:(unsigned char)(y)[0], ((unsigned char)(x)[1]>(unsigned char)(y)[1])?(unsigned char)(x)[1]:(unsigned char)(y)[1], ((unsigned char)(x)[2]>(unsigned char)(y)[2])?(unsigned char)(x)[2]:(unsigned char)(y)[2], ((unsigned char)(x)[3]>(unsigned char)(y)[3])?(unsigned char)(x)[3]:(unsigned char)(y)[3]}
Available macros:
gap8_maxu4(x, y)
__MAXU4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __MAXU4(), and gap8_maxu4().
| v2s __builtin_pulp_min2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise min on a vector of 2 shorts.
Returns (v2s) {((signed short)(x)[0]<(signed short)(y)[0])?((signed short)(x)[0]):((signed short)(y)[0]), ((signed short)(x)[1]<(signed short)(y)[1])?((signed short)(x)[1]):((signed short)(y)[1])}
Available macros:
gap8_min2(x, y)
__MIN2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __MIN2(), and gap8_min2().
| v4s __builtin_pulp_min4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise min on a vector of 4 bytes.
Returns (v4s) {((signed char)(x)[0]<(signed char)(y)[0])?(signed char)(x)[0]:(signed char)(y)[0], ((signed char)(x)[1]<(signed char)(y)[1])?(signed char)(x)[1]:(signed char)(y)[1], ((signed char)(x)[2]<(signed char)(y)[2])?(signed char)(x)[2]:(signed char)(y)[2], ((signed char)(x)[3]<(signed char)(y)[3])?(signed char)(x)[3]:(signed char)(y)[3]}
Available macros:
gap8_min4(x, y)
__MIN4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __MIN4(), and gap8_min4().
| v2u __builtin_pulp_minu2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise unsigned min on a vector of 2 shorts.
Returns (v2u) {((unsigned short)(x)[0]<(unsigned short)(y)[0])?(unsigned short)(x)[0]:(unsigned short)(y)[0], ((unsigned short)(x)[1]<(unsigned short)(y)[1])?(unsigned short)(x)[1]:(unsigned short)(y)[1]}
Available macros:
gap8_minu2(x, y)
__MINU2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __MINU2(), and gap8_minu2().
| v4u __builtin_pulp_minu4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise unsigned min on a vector of 4 bytes.
Returns (v4u) {((unsigned char)(x)[0]<(unsigned char)(y)[0])?(unsigned char)(x)[0]:(unsigned char)(y)[0], ((unsigned char)(x)[1]<(unsigned char)(y)[1])?(unsigned char)(x)[1]:(unsigned char)(y)[1], ((unsigned char)(x)[2]<(unsigned char)(y)[2])?(unsigned char)(x)[2]:(unsigned char)(y)[2], ((unsigned char)(x)[3]<(unsigned char)(y)[3])?(unsigned char)(x)[3]:(unsigned char)(y)[3]}
Available macros:
gap8_minu4(x, y)
__MINU4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __MINU4(), and gap8_minu4().
| v2u __builtin_pulp_neg2 | ( | v2s | x | ) |
Element wise unary minus on a vector of 2 shorts.
Returns (v2s) {-(x)[0], -(x)[1]}
Available macros:
gap8_neg2(x)
__NEG2(x) | x | A vector of 2 shorts |
Referenced by __NEG2(), and gap8_neg2().
| v4u __builtin_pulp_neg4 | ( | v4s | x | ) |
Element wise unary minus on a vector of 4 bytes.
Returns (v4s) {-(x)[0], -(x)[1], -(x)[2], -(x)[3])}
Available macros:
gap8_neg4(x)
__NEG4(x) | x | A vector of 4 bytes |
Referenced by __NEG4(), and gap8_neg4().
| v2s __builtin_pulp_or2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise bitwise or on a vector of 2 shorts.
Returns (v2s) {(x)[0]|(y)[0], (x)[1]|(y)[1]}
Available macros:
gap8_or2(x, y)
__OR2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __OR2(), and gap8_or2().
| v4s __builtin_pulp_or4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise bitwise or on a vector of 4 bytes.
Returns (v4s) {(x)[0]|(y)[0], (x)[1]|(y)[1], (x)[2]|(y)[2], (x)[3]|(y)[3]}
Available macros:
gap8_or4(x, y)
__OR4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __OR4(), and gap8_or4().
| v2s __builtin_pulp_pack2 | ( | short int | x, |
| short int | y | ||
| ) |
Pack 2 short int into a vector
Returns ((v2s) {(signed short) (x), (signed short) (y)}). gcc vector notation.
Available macros:
gap8_pack2(x, y);
__PACK2(x, y); | x | Argument going to vect[0] |
| y | Argument going to vect[1] |
Referenced by __PACK2(), __PACKU2(), gap8_pack2(), and gap8_packu2().
| v4s __builtin_pulp_pack4 | ( | char | x, |
| char | y, | ||
| char | z, | ||
| char | t | ||
| ) |
Pack 4 bytes into a vector
Returns ((v4s) {(signed char) (x), (signed char) (y), (signed char) (z), (signed char) (t)}). gcc vector notation.
Available macros:
gap8_pack4(x, y, z, t);
__PACK4(x, y, z, t); | x | Argument going to Vect[0] |
| y | Argument going to Vect[1] |
| z | Argument going to Vect[2] |
| t | Argument going to Vect[3] |
Referenced by __PACK4(), __PACKU4(), gap8_pack4(), and gap8_packu4().
| v2s __builtin_pulp_shuffle2h | ( | v2s | x, |
| v2s | y, | ||
| v2s | mask | ||
| ) |
Construct a permutation of elements from two vectors and return a vector of the same type as the input vector(s). The mask is an integral vector with the same width (W) and element count (N) as the output vector.
The elements of the input vectors are numbered in memory ordering of vec0 beginning at 0 and vec1 beginning at N. The elements of mask are considered modulo 2*N.
Available macros:
__builtin_shuffle(x, y, mask)
| x | A vector of 2 short ints |
| y | A vector of 2 short ints |
| mask | A vector of 2 shorts, member i, in [0..3], states that x[mask[i]] (if i<=1) or y[mask[i]] (if i>1) should be the ith member in the ouput vector |
| v4s __builtin_pulp_shuffle4b | ( | v4s | x, |
| v4s | y, | ||
| v4s | mask | ||
| ) |
Construct a permutation of elements from two vectors and return a vector of the same type as the input vector(s). The mask is an integral vector with the same width (W) and element count (N) as the output vector.
The elements of the input vectors are numbered in memory ordering of vec0 beginning at 0 and vec1 beginning at N. The elements of mask are considered modulo 2*N.
Available macros:
__builtin_shuffle(x, y, mask)
| x | A vector of 4 bytes |
| y | A vector of 4 bytes |
| mask | A vector of 4 bytes, member i, in [0..7], states that x[mask[i]] (if i<=3) or y[mask[i]] (if i>3) should be the ith member in the ouput vector |
| v4s __builtin_pulp_shuffleb | ( | v4s | x, |
| v4s | mask | ||
| ) |
Permutes vector elements of x according to positions given in mask (a vector).
Constructs a permutation of elements from input x vector and return a vector of the same type as the input vector. The mask is an integral vector with the same width (W) and element count (N) as the output vector.
The elements of the input vector are numbered in memory ordering beginning at 0. The elements of mask are considered modulo N.
Available macros:
__builtin_shuffle(x, mask)
| x | A vector of 4 bytes |
| mask | A vector of 4 bytes, member i, in [0..3], states that x[mask[i]] should be the ith member in the ouput vector |
| v2s __builtin_pulp_shuffleh | ( | v2s | x, |
| v2s | mask | ||
| ) |
Permutes vector elements of x according to positions given in mask (a vector).
Constructs a permutation of elements from input x vector and return a vector of the same type as the input vector. The mask is an integral vector with the same width (W) and element count (N) as the output vector.
The elements of the input vector are numbered in memory ordering beginning at 0. The elements of mask are considered modulo N.
Available macros:
__builtin_shuffle(x, mask)
| x | A vector of 2 short ints |
| mask | A vector of 2 shorts, member i, in [0..1], states that x[mask[i]] should be the ith member in the ouput vector |
| v2s __builtin_pulp_sll2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise logical shift left on a vector of 2 shorts.
Returns (v2s) {(x)[0]<<(y)[0], (x)[1]<<(y)[1]}
Available macros:
gap8_sll2(x, y)
__SLL2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __SLL2(), and gap8_sll2().
| v4s __builtin_pulp_sll4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise logical shift left on a vector of 4 bytes.
Returns (v4s) {(x)[0]<<(y)[0], (x)[1]<<(y)[1], (x)[2]<<(y)[2], (x)[3]<<(y)[3]}}
Available macros:
gap8_sll4(x, y)
__SLL4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __SLL4(), and gap8_sll4().
| v2s __builtin_pulp_sra2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise arithmetic shift right on a vector of 2 shorts.
Returns (v2s) {((signed short)(x)[0]>>(signed short)(y)[0]), ((signed short)(x)[1]>>(signed short)(y)[1])}
Available macros:
gap8_sra2(x, y)
__SRA2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __SRA2(), and gap8_sra2().
| v4s __builtin_pulp_sra4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise arithmetic shift right on a vector of 4 bytes.
Returns (v4s) {((signed char)(x)[0]>>(signed char)(y)[0]), ((signed char)(x)[1]>>(signed char)(y)[1]), ((signed char)(x)[2]>>(signed char)(y)[2]), ((signed char)(x)[3]>>(signed char)(y)[3])}
Available macros:
gap8_sra4(x, y)
__SRA4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __SRA4(), and gap8_sra4().
| v2u __builtin_pulp_srl2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise logical shift right on a vector of 2 shorts.
Returns (v2u) {((unsigned short)(x)[0]>>(unsigned short)(y)[0]), ((unsigned short)(x)[1]>>(unsigned short)(y)[1])}
Available macros:
gap8_srl2(x, y)
__SRL2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __SRL2(), and gap8_srl2().
| v4u __builtin_pulp_srl4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise logical shift right on a vector of 4 bytes.
Returns (v4u) {((unsigned char)(x)[0]>>(unsigned char)(y)[0]), ((unsigned char)(x)[1]>>(unsigned char)(y)[1]), ((unsigned char)(x)[2]>>(unsigned char)(y)[2]), ((unsigned char)(x)[3]>>(unsigned char)(y)[3])}
Available macros:
gap8_srl4(x, y)
__SRL4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __SRL4(), and gap8_srl4().
| v2s __builtin_pulp_sub2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise substraction on a vector of shorts.
Returns (v2s) {(x)[0]-(y)[0], (x)[1]-(y)[1]}
Available macros:
gap8_sub2(x, y)
__SUB2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __SUB2(), and gap8_sub2().
| v2s __builtin_pulp_sub2div2 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise substraction on a vector of 2 shorts followed by a division by 2.
Returns ((x)-(y))>>(v2s) {1, 1}
Available macros:
gap8_sub2div2(x, y)
__SUB2DIV2(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __SUB2DIV2(), and gap8_sub2div2().
| v2s __builtin_pulp_sub2div4 | ( | v2s | x, |
| v2s | y | ||
| ) |
Element wise substraction on a vector of 2 shorts followed by a division by 4.
Returns ((x)-(y))>>(v2s) {2, 2}
Available macros:
gap8_sub2div4(x, y)
__SUB2DIV4(x, y) | x | A vector of 2 shorts |
| y | A vector of 2 shorts |
Referenced by __SUB2DIV4(), and gap8_sub2div4().
| v4s __builtin_pulp_sub4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise substraction on a vector of 4 bytes.
Returns (v4s) {(x)[0]-(y)[0], (x)[1]-(y)[1], (x)[2]-(y)[2], (x)[3]-(y)[3]}
Available macros:
gap8_sub4(x, y)
__SUB4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __SUB4(), and gap8_sub4().
| v4s __builtin_pulp_sub4div2 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise substraction on a vector of 4 bytes followed by a division by 2.
Returns ((x)-(y))>>(v2s) {1, 1}
Available macros:
gap8_sub4div2(x, y)
__SUB4DIV2(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __SUB4DIV2(), and gap8_sub4div2().
| v4s __builtin_pulp_sub4div4 | ( | v4s | x, |
| v4s | y | ||
| ) |
Element wise substraction on a vector of 4 bytes followed by a division by 4.
Returns ((x)-(y))>>(v2s) {2, 2}
Available macros:
gap8_sub4div4(x, y)
__SUB4DIV4(x, y) | x | A vector of 4 bytes |
| y | A vector of 4 bytes |
Referenced by __SUB4DIV4(), and gap8_sub4div4().