gcc/testsuite/gcc.target/powerpc/vsx-load-element-extend-char.c

   1 /*
   2    Test of vec_xl_sext and vec_xl_zext (load into rightmost
   3    vector element and zero/sign extend). */
   4
   5 /* { dg-do run { target power10_hw } } */
   6 /* { dg-do compile { target { ! power10_hw } } } */
   7 /* { dg-require-effective-target power10_ok } */
   8 /* { dg-require-effective-target int128 } */
   9 /* { dg-options "-mdejagnu-cpu=power10 -O3 -save-temps" } */
  10
  11 /* At the time of writing, the number of lxvrbx instructions is
  12    double what we expect because we are generating a
  13    .constprop copy of the function.  */
  14 /* { dg-final { scan-assembler-times {\mlxvrbx\M} 4 } } */
  15 /* { dg-final { scan-assembler-times {\mlbx\M} 0 } } */
  16
  17 #define NUM_VEC_ELEMS 16
  18 #define ITERS 16
  19
  20 /*
  21 Codegen at time of writing is a lxvrbx for both the
  22 zero and sign extended tests.  The sign extension test
  23 also uses mfvsr*d, extsb, mtvsrdd, vextsd2q.
  24
  25 0000000010000c90 <test_sign_extended_load>:
  26     10000c90:   1a 18 04 7c     lxvrbx  vs0,r4,r3
  27     10000c94:   66 00 0b 7c     mfvsrd  r11,vs0
  28     10000c98:   66 02 0a 7c     mfvsrld r10,vs0
  29     10000c9c:   74 07 4a 7d     extsb   r10,r10
  30     10000ca0:   67 53 40 7c     mtvsrdd vs34,0,r10
  31     10000ca4:   02 16 5b 10     vextsd2q v2,v2
  32     10000ca8:   20 00 80 4e     blr
  33
  34 0000000010000cc0 <test_zero_extended_unsigned_load>:
  35     10000cc0:   1b 18 44 7c     lxvrbx  vs34,r4,r3
  36     10000cc4:   20 00 80 4e     blr
  37 */
  38
  39 #include <altivec.h>
  40 #include <stdio.h>
  41 #include <inttypes.h>
  42 #include <string.h>
  43 #include <stdlib.h>
  44
  45 long long buffer[8];
  46 unsigned long verbose=0;
  47
  48 char initbuffer[64] = {
  49         0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
  50                         0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x80,
  51         0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  52                         0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0x90,
  53         0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
  54                         0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xa0,
  55         0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
  56                         0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xb0
  57 };
  58
  59 vector signed __int128 signed_expected[16] = {
  60         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000011},
  61         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000012},
  62         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000013},
  63         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000014},
  64         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000015},
  65         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000016},
  66         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000017},
  67         { (__int128) 0x0000000000000000 << 64 | (__int128) 0x0000000000000018},
  68         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff89},
  69         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff8a},
  70         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff8b},
  71         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff8c},
  72         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff8d},
  73         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff8e},
  74         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff8f},
  75         { (__int128) 0xffffffffffffffff << 64 | (__int128) 0xffffffffffffff80}
  76 };
  77
  78 vector unsigned __int128 unsigned_expected[16] = {
  79         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000011},
  80         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000012},
  81         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000013},
  82         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000014},
  83         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000015},
  84         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000016},
  85         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000017},
  86         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000018},
  87         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000089},
  88         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x000000000000008a},
  89         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x000000000000008b},
  90         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x000000000000008c},
  91         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x000000000000008d},
  92         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x000000000000008e},
  93         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x000000000000008f},
  94         { (unsigned __int128) 0x0000000000000000 << 64 | (unsigned __int128) 0x0000000000000080}
  95 };
  96
  97 __attribute__ ((noinline))
  98 vector signed __int128 test_sign_extended_load(int RA, signed char * RB) {
  99         return vec_xl_sext (RA, RB);
 100 }
 101
 102 __attribute__ ((noinline))
 103 vector unsigned __int128 test_zero_extended_unsigned_load(int RA, unsigned char * RB) {
 104         return vec_xl_zext (RA, RB);
 105 }
 106
 107 int main (int argc, char *argv [])
 108 {
 109    int iteration=0;
 110    int mismatch=0;
 111    vector signed __int128 signed_result_v;
 112    vector unsigned __int128 unsigned_result_v;
 113 #if VERBOSE
 114    verbose=1;
 115    printf("%s %s\n", __DATE__, __TIME__);
 116 #endif
 117
 118   memcpy(&buffer, &initbuffer, sizeof(buffer));
 119
 120    if (verbose) {
 121            printf("input buffer:\n");
 122            for (int k=0;k<64;k++) {
 123                    printf("%x ",initbuffer[k]);
 124                    if (k && (k+1)%16==0) printf("\n");
 125            }
 126            printf("signed_expected:\n");
 127            for (int k=0;k<ITERS;k++) {
 128                 printf("%llx ",signed_expected[iteration][0]>>64);
 129                 printf(" %llx \n",signed_expected[iteration][0]&0xffffffffffffffff);
 130                    printf("\n");
 131            }
 132            printf("unsigned_expected:\n");
 133            for (int k=0;k<ITERS;k++) {
 134                 printf("%llx ",signed_expected[iteration][0]>>64);
 135                 printf(" %llx \n",signed_expected[iteration][0]&0xffffffffffffffff);
 136                    printf("\n");
 137            }
 138    }
 139
 140    for (iteration = 0; iteration < ITERS ; iteration++ ) {
 141       signed_result_v = test_sign_extended_load (iteration, (signed char*)buffer);
 142       if (signed_result_v[0] != signed_expected[iteration][0] ) {
 143                 mismatch++;
 144                 printf("Unexpected results from signed load. i=%d \n", iteration);
 145                 printf("got:      %llx ",signed_result_v[0]>>64);
 146                 printf(" %llx \n",signed_result_v[0]&0xffffffffffffffff);
 147                 printf("expected: %llx ",signed_expected[iteration][0]>>64);
 148                 printf(" %llx \n",signed_expected[iteration][0]&0xffffffffffffffff);
 149                 fflush(stdout);
 150       }
 151    }
 152
 153    for (iteration = 0; iteration < ITERS ; iteration++ ) {
 154       unsigned_result_v = test_zero_extended_unsigned_load (iteration, (unsigned char*)buffer);
 155       if (unsigned_result_v[0] != unsigned_expected[iteration][0]) {
 156                 mismatch++;
 157                 printf("Unexpected results from unsigned load. i=%d \n", iteration);
 158                 printf("got:      %llx ",unsigned_result_v[0]>>64);
 159                 printf(" %llx \n",unsigned_result_v[0]&0xffffffffffffffff);
 160                 printf("expected: %llx ",unsigned_expected[iteration][0]>>64);
 161                 printf(" %llx \n",unsigned_expected[iteration][0]&0xffffffffffffffff);
 162                 fflush(stdout);
 163       }
 164    }
 165
 166    if (mismatch) {
 167       printf("%d mismatches. \n",mismatch);
 168       abort();
 169    }
 170    return 0;
 171 }
 172