| #include <altivec.h> | |
| /* Test various ways of creating vectors with 2 double words and accessing the | |
| elements. This include files supports: | |
| testing double | |
| testing long on 64-bit systems | |
| testing long long on 32-bit systems. | |
| The endian support is: | |
| big endian | |
| little endian. */ | |
| #ifdef DEBUG | |
| #include <stdio.h> | |
| #define DEBUG0(STR) fputs (STR, stdout) | |
| #define DEBUG2(STR,A,B) printf (STR, A, B) | |
| static int errors = 0; | |
| #else | |
| #include <stdlib.h> | |
| #define DEBUG0(STR) | |
| #define DEBUG2(STR,A,B) | |
| #endif | |
| #if defined(DO_DOUBLE) | |
| #define TYPE double | |
| #define STYPE "double" | |
| #define ZERO 0.0 | |
| #define ONE 1.0 | |
| #define TWO 2.0 | |
| #define THREE 3.0 | |
| #define FOUR 4.0 | |
| #define FIVE 5.0 | |
| #define SIX 6.0 | |
| #define FMT "g" | |
| #elif defined(_ARCH_PPC64) | |
| #define TYPE long | |
| #define STYPE "long" | |
| #define ZERO 0L | |
| #define ONE 1L | |
| #define TWO 2L | |
| #define THREE 3L | |
| #define FOUR 4L | |
| #define FIVE 5L | |
| #define SIX 6L | |
| #define FMT "ld" | |
| #else | |
| #define TYPE long long | |
| #define STYPE "long long" | |
| #define ZERO 0LL | |
| #define ONE 1LL | |
| #define TWO 2LL | |
| #define THREE 3LL | |
| #define FOUR 4LL | |
| #define FIVE 5LL | |
| #define SIX 6LL | |
| #define FMT "lld" | |
| #endif | |
| /* Macros to order the left/right values correctly. */ | |
| #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ | |
| #define INIT_ORDER(A, B) (TYPE) A, (TYPE) B | |
| #define ELEMENT_ORDER(A, B) (TYPE) A, (TYPE) B | |
| #define ENDIAN "-mbig" | |
| #else | |
| #define INIT_ORDER(A, B) (TYPE) B, (TYPE) A | |
| #define ELEMENT_ORDER(A, B) (TYPE) B, (TYPE) A | |
| #define ENDIAN "-mlittle" | |
| #endif | |
| static volatile TYPE five = FIVE; | |
| static volatile TYPE six = SIX; | |
| static volatile vector TYPE s_v12 = { ONE, TWO }; | |
| static volatile vector TYPE g_v34 = { THREE, FOUR }; | |
| __attribute__((__noinline__)) | |
| static void | |
| vector_check (vector TYPE v, TYPE expect_hi, TYPE expect_lo) | |
| { | |
| TYPE actual_hi, actual_lo; | |
| #ifdef DEBUG | |
| const char *pass_fail; | |
| #endif | |
| __asm__ ("xxlor %x0,%x1,%x1" : "=&wa" (actual_hi) : "wa" (v)); | |
| __asm__ ("xxpermdi %x0,%x1,%x1,3" : "=&wa" (actual_lo) : "wa" (v)); | |
| #ifdef DEBUG | |
| if ((actual_hi == expect_hi) && (actual_lo == expect_lo)) | |
| pass_fail = ", pass"; | |
| else | |
| { | |
| pass_fail = ", fail"; | |
| errors++; | |
| } | |
| printf ("Expected %" FMT ", %" FMT ", got %" FMT ", %" FMT "%s\n", | |
| expect_hi, expect_lo, | |
| actual_hi, actual_lo, | |
| pass_fail); | |
| #else | |
| if ((actual_hi != expect_hi) || (actual_lo != expect_lo)) | |
| abort (); | |
| #endif | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| combine (TYPE op0, TYPE op1) | |
| { | |
| return (vector TYPE) { op0, op1 }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| combine_insert (TYPE op0, TYPE op1) | |
| { | |
| vector TYPE ret = (vector TYPE) { ZERO, ZERO }; | |
| ret = vec_insert (op0, ret, 0); | |
| ret = vec_insert (op1, ret, 1); | |
| return ret; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract_00 (vector TYPE a, vector TYPE b) | |
| { | |
| return (vector TYPE) { vec_extract (a, 0), vec_extract (b, 0) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract_01 (vector TYPE a, vector TYPE b) | |
| { | |
| return (vector TYPE) { vec_extract (a, 0), vec_extract (b, 1) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract_10 (vector TYPE a, vector TYPE b) | |
| { | |
| return (vector TYPE) { vec_extract (a, 1), vec_extract (b, 0) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract_11 (vector TYPE a, vector TYPE b) | |
| { | |
| return (vector TYPE) { vec_extract (a, 1), vec_extract (b, 1) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract2_0s (vector TYPE a, TYPE b) | |
| { | |
| return (vector TYPE) { vec_extract (a, 0), b }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract2_1s (vector TYPE a, TYPE b) | |
| { | |
| return (vector TYPE) { vec_extract (a, 1), b }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract2_s0 (TYPE a, vector TYPE b) | |
| { | |
| return (vector TYPE) { a, vec_extract (b, 0) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract2_s1 (TYPE a, vector TYPE b) | |
| { | |
| return (vector TYPE) { a, vec_extract (b, 1) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| concat_extract_nn (vector TYPE a, vector TYPE b, size_t i, size_t j) | |
| { | |
| return (vector TYPE) { vec_extract (a, i), vec_extract (b, j) }; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| array_0 (vector TYPE v, TYPE a) | |
| { | |
| v[0] = a; | |
| return v; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| array_1 (vector TYPE v, TYPE a) | |
| { | |
| v[1] = a; | |
| return v; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| array_01 (vector TYPE v, TYPE a, TYPE b) | |
| { | |
| v[0] = a; | |
| v[1] = b; | |
| return v; | |
| } | |
| __attribute__((__noinline__)) | |
| static vector TYPE | |
| array_01b (TYPE a, TYPE b) | |
| { | |
| vector TYPE v = (vector TYPE) { 0, 0 }; | |
| v[0] = a; | |
| v[1] = b; | |
| return v; | |
| } | |
| int | |
| main (void) | |
| { | |
| vector TYPE a = (vector TYPE) { ONE, TWO }; | |
| vector TYPE b = (vector TYPE) { THREE, FOUR }; | |
| size_t i, j; | |
| vector TYPE z = (vector TYPE) { ZERO, ZERO }; | |
| DEBUG2 ("Endian: %s, type: %s\n", ENDIAN, STYPE); | |
| DEBUG0 ("\nStatic/global initialization\n"); | |
| vector_check (s_v12, INIT_ORDER (1, 2)); | |
| vector_check (g_v34, INIT_ORDER (3, 4)); | |
| DEBUG0 ("\nVector via constant runtime intiialization\n"); | |
| vector_check (a, INIT_ORDER (1, 2)); | |
| vector_check (b, INIT_ORDER (3, 4)); | |
| DEBUG0 ("\nCombine scalars using vector initialization\n"); | |
| vector_check (combine (1, 2), INIT_ORDER (1, 2)); | |
| vector_check (combine (3, 4), INIT_ORDER (3, 4)); | |
| DEBUG0 ("\nSetup with vec_insert\n"); | |
| a = combine_insert (1, 2); | |
| b = combine_insert (3, 4); | |
| vector_check (a, ELEMENT_ORDER (1, 2)); | |
| vector_check (b, ELEMENT_ORDER (3, 4)); | |
| DEBUG0 ("\nTesting array syntax\n"); | |
| vector_check (array_0 (a, FIVE), ELEMENT_ORDER (5, 2)); | |
| vector_check (array_1 (b, SIX), ELEMENT_ORDER (3, 6)); | |
| vector_check (array_01 (z, FIVE, SIX), ELEMENT_ORDER (5, 6)); | |
| vector_check (array_01b (FIVE, SIX), ELEMENT_ORDER (5, 6)); | |
| vector_check (array_0 (a, five), ELEMENT_ORDER (5, 2)); | |
| vector_check (array_1 (b, six), ELEMENT_ORDER (3, 6)); | |
| vector_check (array_01 (z, five, six), ELEMENT_ORDER (5, 6)); | |
| vector_check (array_01b (five, six), ELEMENT_ORDER (5, 6)); | |
| DEBUG0 ("\nTesting concat and extract\n"); | |
| vector_check (concat_extract_00 (a, b), INIT_ORDER (1, 3)); | |
| vector_check (concat_extract_01 (a, b), INIT_ORDER (1, 4)); | |
| vector_check (concat_extract_10 (a, b), INIT_ORDER (2, 3)); | |
| vector_check (concat_extract_11 (a, b), INIT_ORDER (2, 4)); | |
| DEBUG0 ("\nTesting concat and extract #2\n"); | |
| vector_check (concat_extract2_0s (a, FIVE), INIT_ORDER (1, 5)); | |
| vector_check (concat_extract2_1s (a, FIVE), INIT_ORDER (2, 5)); | |
| vector_check (concat_extract2_s0 (SIX, a), INIT_ORDER (6, 1)); | |
| vector_check (concat_extract2_s1 (SIX, a), INIT_ORDER (6, 2)); | |
| DEBUG0 ("\nTesting variable concat and extract\n"); | |
| for (i = 0; i < 2; i++) | |
| { | |
| for (j = 0; j < 2; j++) | |
| { | |
| static struct { | |
| TYPE hi; | |
| TYPE lo; | |
| } hilo[2][2] = | |
| { { { ONE, THREE }, { ONE, FOUR } }, | |
| { { TWO, THREE }, { TWO, FOUR } } }; | |
| vector_check (concat_extract_nn (a, b, i, j), | |
| INIT_ORDER (hilo[i][j].hi, hilo[i][j].lo)); | |
| } | |
| } | |
| DEBUG0 ("\nTesting separate function\n"); | |
| vector_check (combine (vec_extract (a, 0), vec_extract (b, 0)), | |
| INIT_ORDER (1, 3)); | |
| vector_check (combine (vec_extract (a, 0), vec_extract (b, 1)), | |
| INIT_ORDER (1, 4)); | |
| vector_check (combine (vec_extract (a, 1), vec_extract (b, 0)), | |
| INIT_ORDER (2, 3)); | |
| vector_check (combine (vec_extract (a, 1), vec_extract (b, 1)), | |
| INIT_ORDER (2, 4)); | |
| vector_check (combine_insert (vec_extract (a, 0), vec_extract (b, 0)), | |
| ELEMENT_ORDER (1, 3)); | |
| vector_check (combine_insert (vec_extract (a, 0), vec_extract (b, 1)), | |
| ELEMENT_ORDER (1, 4)); | |
| vector_check (combine_insert (vec_extract (a, 1), vec_extract (b, 0)), | |
| ELEMENT_ORDER (2, 3)); | |
| vector_check (combine_insert (vec_extract (a, 1), vec_extract (b, 1)), | |
| ELEMENT_ORDER (2, 4)); | |
| #if defined(DO_DOUBLE) | |
| DEBUG0 ("\nTesting explicit 2df concat\n"); | |
| vector_check (__builtin_vsx_concat_2df (FIVE, SIX), INIT_ORDER (5, 6)); | |
| vector_check (__builtin_vsx_concat_2df (five, six), INIT_ORDER (5, 6)); | |
| #elif defined(_ARCH_PPC64) | |
| DEBUG0 ("\nTesting explicit 2di concat\n"); | |
| vector_check (__builtin_vsx_concat_2di (FIVE, SIX), INIT_ORDER (5, 6)); | |
| vector_check (__builtin_vsx_concat_2di (five, six), INIT_ORDER (5, 6)); | |
| #else | |
| DEBUG0 ("\nSkip explicit 2di concat on 32-bit\n"); | |
| #endif | |
| #ifdef DEBUG | |
| if (errors) | |
| printf ("\n%d error%s were found", errors, (errors == 1) ? "" : "s"); | |
| else | |
| printf ("\nNo errors were found.\n"); | |
| return errors; | |
| #else | |
| return 0; | |
| #endif | |
| } |