memcheck/tests/common/sh-mem-vec128.tmpl.c

   1
   2 // Tests shadow memory correctness for 16-byte/32-byte/etc. vector
   3 // loads/stores. Requires vector_copy() and VECTOR_BYTES to be
   4 // specified somehow.
   5
   6 #ifndef VECTOR_BYTES
   7 #error "VECTOR_BYTES must be defined"
   8 #endif
   9
  10 #include <assert.h>
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include "tests/malloc.h"
  15 #include "memcheck/memcheck.h"
  16
  17 // What we're actually testing
  18 // .. is vector_copy, which should be defined before this point
  19
  20 // All the sizes here are in *bytes*, not bits.
  21
  22 typedef unsigned char        U1;
  23 typedef unsigned short       U2;
  24 typedef unsigned int         U4;
  25 typedef unsigned long long   U8;
  26 typedef unsigned long int    UWord;
  27
  28 typedef unsigned char        Bool;
  29 #define  True   ((Bool)1)
  30 #define  False  ((Bool)0)
  31
  32 #define CFENCE __asm__ __volatile__("":::"cc","memory")
  33
  34 static __attribute__((noinline)) const char* get_endianness ( void )
  35 {
  36    volatile U4 w32 = 0x88776655;
  37    volatile U1* p = (U1*)&w32;
  38    if (p[0] == 0x55) {
  39       assert(p[3] == 0x88);
  40       return "little";
  41    }
  42    if (p[0] == 0x88) {
  43       assert(p[3] == 0x55);
  44       return "big";
  45    }
  46    assert(0);
  47 }
  48
  49 static inline U4 randomU4 ( void )
  50 {
  51    static U4 n = 0;
  52    /* From "Numerical Recipes in C" 2nd Edition */
  53    n = 1664525UL * n + 1013904223UL;
  54    return n;
  55 }
  56
  57 static inline U1 randomU1 ( void )
  58 {
  59    return 0xFF & (randomU4() >> 13);
  60 }
  61
  62 #define N_BYTES  80000
  63 #define N_EVENTS (N_BYTES * 2)
  64
  65 // Return x, but with its definedness bits set to be its own value bits
  66 static inline U1 self_shadow ( U1 x )
  67 {
  68    U1 res = 0xFF;
  69    (void) VALGRIND_MAKE_MEM_UNDEFINED(&res, 1);
  70    res &= x;
  71    return res;
  72 }
  73
  74 static inline U1 get_shadow ( U1 x )
  75 {
  76    U1 res = 0;
  77    U4 r = VALGRIND_GET_VBITS(&x, &res, 1);
  78    assert(r == 1 || r == 0);
  79    return res;
  80 }
  81
  82 static inline U1 make_def ( U1 x )
  83 {
  84    U1 y = x;
  85    (void) VALGRIND_MAKE_MEM_DEFINED(&y, 1);
  86    return y;
  87 }
  88
  89 static inline U1 make_undef ( U1 x )
  90 {
  91    U1 y = x;
  92    (void) VALGRIND_MAKE_MEM_UNDEFINED(&y, 1);
  93    return y;
  94 }
  95
  96 static void make_noaccess ( U1* dst )
  97 {
  98   (void) VALGRIND_MAKE_MEM_NOACCESS(dst, 1);
  99 }
 100
 101 static void apply ( void(*fn)(U4,Bool), U4 arg1, Bool arg2 )
 102 {
 103    switch (arg1 & (32-1)) {
 104       case 0: CFENCE; fn(arg1, arg2); CFENCE; break;
 105       case 1: CFENCE; fn(arg1, arg2); CFENCE; break;
 106       case 2: CFENCE; fn(arg1, arg2); CFENCE; break;
 107       case 3: CFENCE; fn(arg1, arg2); CFENCE; break;
 108       case 4: CFENCE; fn(arg1, arg2); CFENCE; break;
 109       case 5: CFENCE; fn(arg1, arg2); CFENCE; break;
 110       case 6: CFENCE; fn(arg1, arg2); CFENCE; break;
 111       case 7: CFENCE; fn(arg1, arg2); CFENCE; break;
 112       case 8: CFENCE; fn(arg1, arg2); CFENCE; break;
 113       case 9: CFENCE; fn(arg1, arg2); CFENCE; break;
 114       case 10: CFENCE; fn(arg1, arg2); CFENCE; break;
 115       case 11: CFENCE; fn(arg1, arg2); CFENCE; break;
 116       case 12: CFENCE; fn(arg1, arg2); CFENCE; break;
 117       case 13: CFENCE; fn(arg1, arg2); CFENCE; break;
 118       case 14: CFENCE; fn(arg1, arg2); CFENCE; break;
 119       case 15: CFENCE; fn(arg1, arg2); CFENCE; break;
 120       case 16: CFENCE; fn(arg1, arg2); CFENCE; break;
 121       case 17: CFENCE; fn(arg1, arg2); CFENCE; break;
 122       case 18: CFENCE; fn(arg1, arg2); CFENCE; break;
 123       case 19: CFENCE; fn(arg1, arg2); CFENCE; break;
 124       case 20: CFENCE; fn(arg1, arg2); CFENCE; break;
 125       case 21: CFENCE; fn(arg1, arg2); CFENCE; break;
 126       case 22: CFENCE; fn(arg1, arg2); CFENCE; break;
 127       case 23: CFENCE; fn(arg1, arg2); CFENCE; break;
 128       case 24: CFENCE; fn(arg1, arg2); CFENCE; break;
 129       case 25: CFENCE; fn(arg1, arg2); CFENCE; break;
 130       case 26: CFENCE; fn(arg1, arg2); CFENCE; break;
 131       case 27: CFENCE; fn(arg1, arg2); CFENCE; break;
 132       case 28: CFENCE; fn(arg1, arg2); CFENCE; break;
 133       case 29: CFENCE; fn(arg1, arg2); CFENCE; break;
 134       case 30: CFENCE; fn(arg1, arg2); CFENCE; break;
 135       case 31: CFENCE; fn(arg1, arg2); CFENCE; break;
 136       default: CFENCE; fn(arg1, arg2); CFENCE; break;
 137    }
 138 }
 139
 140   // Try doing some partial-loads-ok/not-ok testing.
 141   /* Test cases:
 142      - load, aligned, all no-access
 143          ==> addr err
 144      - load, aligned, 1 to VECTOR_BYTES-1 initial bytes accessible,
 145              then at least one unaccessible byte,
 146              then remaining bytes in any state.
 147          ==> if PLO then no error, but returned V bits are undefined
 148                 for unaccessible bytes
 149              else
 150                 error; and V bits are defined for unaccessible bytes
 151
 152      All of the above, but non-aligned:
 153         -- all return an addressing error
 154   */
 155
 156 static void do_partial_load_case ( U4 nInitialValid, Bool aligned )
 157 {
 158      fprintf(stderr,
 159        "------ PL %s case with %u leading acc+def bytes ------\n\n",
 160              aligned ? "Aligned" : "Unaligned", nInitialValid);
 161
 162      void *temp;
 163      if (posix_memalign(&temp, VECTOR_BYTES, 64) != 0)
 164          abort();
 165      U1* block = temp;
 166      U4 j;
 167      for (j = 0; j < 64; j++) block[j] = 0;
 168
 169      if (!aligned) block++;
 170
 171      // Make the block have this pattern:
 172      // block[0 .. i-1]  accessible and defined
 173      // block[i .. VECTOR_BYTES-1]   repeating NOACCESS, UNDEF, DEF
 174      // hence block[i], at the very least, is always NOACCESS
 175      U4 i = nInitialValid;
 176      for (j = i; j < VECTOR_BYTES; j++) {
 177         switch ((j-i) % 3) {
 178            case 0: make_noaccess(&block[j]); break;
 179            case 1: block[j] = make_undef(block[j]); break;
 180            case 2: /* already acc and def */ break;
 181         }
 182      }
 183
 184      // Do the access, possibly generating an error, and show the
 185      // resulting V bits
 186      U1 dst[VECTOR_BYTES];
 187      vector_copy(&dst[0], block);
 188
 189      U1 dst_vbits[VECTOR_BYTES];
 190      U4 r = VALGRIND_GET_VBITS(&dst[0], &dst_vbits[0], VECTOR_BYTES);
 191      assert(r == 1 || r == 0);
 192
 193      fprintf(stderr, "\n");
 194      for (j = 0; j < VECTOR_BYTES; j++) {
 195         fprintf(stderr, "%c", dst_vbits[j] == 0 ? 'd'
 196                               : dst_vbits[j] == 0xFF ? 'U' : '?');
 197      }
 198      fprintf(stderr, "\n\n");
 199
 200      // Also let's use the resulting value, to check we get an undef
 201      // error
 202      U1 sum = 0;
 203      for (j = 0; j < VECTOR_BYTES; j++)
 204         sum ^= dst[j];
 205
 206      if (sum == 42) {
 207         CFENCE; fprintf(stderr, "%s", ""); CFENCE;
 208      } else {
 209         CFENCE; fprintf(stderr, "%s", ""); CFENCE;
 210      }
 211
 212      fprintf(stderr, "\n");
 213
 214      if (!aligned) block--;
 215      free(block);
 216 }
 217
 218 int main ( void )
 219 {
 220   fprintf(stderr, "sh-mem-vec%d: config: %s-endian, %d-bit word size\n",
 221           VECTOR_BYTES * 8, get_endianness(), (int)(8 * sizeof(void*)));
 222
 223   U4 i;
 224   void *temp;
 225   if (posix_memalign(&temp, VECTOR_BYTES, N_BYTES) != 0)
 226       abort();
 227   U1* buf = temp;
 228
 229   // Fill |buf| with bytes, so that zero bits have a zero shadow
 230   // (are defined) and one bits have a one shadow (are undefined)
 231   for (i = 0; i < N_BYTES/2; i++) {
 232      buf[i] = self_shadow( (i & (1<<5)) ? 0x00 : 0xFF );
 233   }
 234   for (     ;  i < N_BYTES; i++) {
 235      buf[i] = self_shadow( randomU1() );
 236   }
 237
 238   // Randomly copy the data around.  Once every 8 srcs/dsts, force
 239   // the src or dst to be aligned.  Once every 64, force both to be
 240   // aligned.  So as to give the fast (aligned) paths some checking.
 241   const U4 n_copies = N_EVENTS;
 242   U4 n_d_aligned = 0;
 243   U4 n_s_aligned = 0;
 244   U4 n_both_aligned = 0;
 245   U4 n_fails = 0;
 246
 247   for (i = 0; i < n_copies; i++) {
 248      U4 si = randomU4() % (N_BYTES-VECTOR_BYTES);
 249      U4 di = randomU4() % (N_BYTES-VECTOR_BYTES);
 250      if (0 == (randomU1() & 7)) si &= ~(VECTOR_BYTES-1);
 251      if (0 == (randomU1() & 7)) di &= ~(VECTOR_BYTES-1);
 252      if (0 == (randomU1() & 63)) { di &= ~(VECTOR_BYTES-1); si &= ~(VECTOR_BYTES-1); }
 253
 254      void* dst = &buf[di];
 255      void* src = &buf[si];
 256
 257      if (0 == (((UWord)src) & (VECTOR_BYTES-1))) n_s_aligned++;
 258      if (0 == (((UWord)dst) & (VECTOR_BYTES-1))) n_d_aligned++;
 259      if (0 == (((UWord)src) & (VECTOR_BYTES-1)) && 0 == (((UWord)dst) & (VECTOR_BYTES-1)))
 260        n_both_aligned++;
 261
 262      vector_copy(dst, src);
 263   }
 264
 265   U4 freq[256];
 266   for (i = 0; i < 256; i++)
 267      freq[i] = 0;
 268
 269   for (i = 0; i < N_BYTES; i++) {
 270      //if (i > 0 && 0 == (i & 0x0F)) fprintf(stderr, "\n");
 271      U1 v_actual = make_def(buf[i]);
 272      U1 v_shadow = get_shadow(buf[i]);
 273      if (v_actual != v_shadow) n_fails++;
 274      //fprintf(stderr, "%02x:%02x ", (U4)v_actual, (U4)v_shadow);
 275      freq[(U4)v_actual]++;
 276   }
 277
 278   fprintf(stderr, "\n");
 279   U4 totFreq = 0;
 280   for (i = 0; i < 256; i++) {
 281      totFreq += freq[i];
 282      if (i > 0 && (0 == (i % 16))) fprintf(stderr, "\n");
 283      fprintf(stderr, "%5u ", freq[i]);
 284   }
 285   assert(totFreq == N_BYTES);
 286
 287   fprintf(stderr, "\n\n");
 288   fprintf(stderr, "%u copies, %u d_aligned, %u s_aligned, %u both_aligned\n",
 289          n_copies, n_d_aligned, n_s_aligned, n_both_aligned);
 290   fprintf(stderr, "%u %s\n", n_fails, n_fails == 0 ? "failures" : "FAILURES");
 291
 292   // Check that we can detect underruns of the block.
 293   fprintf(stderr, "\nExpect 2 x no error\n" );
 294   vector_copy( &buf[100], &buf[0] );
 295   vector_copy( &buf[0],   &buf[100] );
 296
 297   fprintf(stderr, "\nExpect 2 x error\n\n" );
 298   vector_copy( &buf[100], &buf[-1]  ); // invalid rd
 299   vector_copy( &buf[-1],  &buf[100] ); // invalid wr
 300
 301   // and overruns ..
 302   fprintf(stderr, "\nExpect 2 x no error\n" );
 303   vector_copy( &buf[200],            &buf[N_BYTES-VECTOR_BYTES + 0] );
 304   vector_copy( &buf[N_BYTES-VECTOR_BYTES + 0], &buf[200]            );
 305
 306   fprintf(stderr, "\nExpect 2 x error\n\n" );
 307   vector_copy( &buf[200],            &buf[N_BYTES-VECTOR_BYTES + 1] );
 308   vector_copy( &buf[N_BYTES-VECTOR_BYTES + 1], &buf[200]            );
 309
 310   free(buf);
 311   fprintf(stderr, "\n");
 312
 313   for (i = 0; i < VECTOR_BYTES; i++)
 314      apply( do_partial_load_case, i, True/*aligned*/ );
 315
 316   for (i = 0; i < VECTOR_BYTES; i++)
 317      apply( do_partial_load_case, i, False/*not aligned*/ );
 318
 319   return 0;
 320 }