vec_lvsr

Purpose

Returns a vector useful for aligning non-aligned data.

Syntax

d=vec_lvsr(a, b)

Result and argument types

The following table describes the types of the returned value and the function arguments.

d	a	b
`vector4double`	`long`	`double*`
		`_Complex double*`
		`float*`
		`_Complex float*`

Result value

The result value is a quad vector. The elements of the quad vector are generated in the following ways:

Sign: 0
Mantissa:
1. For the first element, the mantissa is the result of following operations:
  - If b is a pointer to a double-precision floating-point value or complex value:
    1. Add a and b.
    2. Mask the result of the previous step with 0b11000.
    3. Subtract the result of the previous step from 32.
    4. Take the integer value of bits 58 - 60 from the result of the previous step.
  - If b is a pointer to a single-precision floating-point value or complex value:
    1. Add a and b.
    2. Mask the result of the previous step with 0b1100.
    3. Subtract the result of the previous step from 16.
    4. Take the integer value of bits 59 - 61 from the result of the previous step.
2. The mantissa is incremented by one for each subsequent element.
  The mantissa is seen as a 3-bit value for the increment operation. That is, incrementing 0b111 produces 0b000.
Exponent: 0x400

You can use the result as an argument of the vec_perm function.

Formula

The following formula is applicable if b is a pointer to a double-precision floating-point value or complex value:

EA = a + b
AA = 32 – (EA AND 0b11000)
Offset = AA_58:60
d[0] = (double) {sign = 0, mantissa =  Offset             , exponent = 0x400}
d[1] = (double) {sign = 0, mantissa = (Offset+1) AND 0b111, exponent = 0x400}
d[2] = (double) {sign = 0, mantissa = (Offset+2) AND 0b111, exponent = 0x400}
d[3] = (double) {sign = 0, mantissa = (Offset+3) AND 0b111, exponent = 0x400}

The following formula is applicable if b is a pointer to a single-precision floating-point value or complex value:

EA = a + b
AA = 16 – (EA AND 0b1100)
Offset = AA_59:61
d[0] = (double) {sign = 0, mantissa =  Offset             , exponent = 0x400}
d[1] = (double) {sign = 0, mantissa = (Offset+1) AND 0b111, exponent = 0x400}
d[2] = (double) {sign = 0, mantissa = (Offset+2) AND 0b111, exponent = 0x400}
d[3] = (double) {sign = 0, mantissa = (Offset+3) AND 0b111, exponent = 0x400}

Note:

AND is the bitwise AND operator.

Example: Storing 8-byte aligned vectors

void my_vec_store(vector4double v, double *arr)
{
   vector4double v1, v2, v3, p, m1, m2, m3;
   /* generate insert masks */
   p = vec_lvsr(0,arr);
   m1 = vec_cmplt(p,p); /* generate vector of all FALSE */
   m2 = vec_neg(m1);    /* generate vector of all TRUE */
   m3 = vec_perm(m1,m2,p);
   /* get existing data */
   v1 = vec_ld(0,arr);
   v2 = vec_ld(0,arr+4);
   /* permute and insert */
   v3 = vec_perm(v,v,p);
   v1 = vec_sel(v1,v3,m3);
   v2 = vec_sel(v3,v2,m3);
   /* store data back */
   vec_st(0,arr,v1);
   vec_st(0,arr+4,v2);
}

Example: Storing 4-byte aligned vectors

void my_vec_store(vector4double v, float *arr)
{
   vector4double v1, v2, v3, p, m1, m2, m3
   /* generate insert masks */
   p = vec_lvsr(0,arr);
   m1 = vec_cmplt(p,p); /* generate vector of all FALSE */
   m2 = vec_neg(m1);    /* generate vector of all TRUE */
   m3 = vec_perm(m1,m2,p);
   /* get existing data */
   v1 = vec_ld(0,arr);
   v2 = vec_ld(0,arr+4);
   /* permute and insert */
   v3 = vec_perm(v,v,p);
   v1 = vec_sel(v1,v3,m3);
   v2 = vec_sel(v3,v2,m3);
   /* store data back */
   vec_st(0,arr,v1);
   vec_st(0,arr+4,v2);
}