l4/pkg/valgrind/src/valgrind-3.6.0-svn/memcheck/tests/sh-mem.c

   1 // This program is a thorough test of the LOADVn/STOREVn shadow memory
   2 // operations.
   3
   4 #include <assert.h>
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include "memcheck/memcheck.h"
   9
  10 // All the sizes here are in *bytes*, not bits.
  11
  12 typedef unsigned char        U1;
  13 typedef unsigned short       U2;
  14 typedef unsigned int         U4;
  15 typedef unsigned long long   U8;
  16
  17 typedef float                F4;
  18 typedef double               F8;
  19
  20 #define SZB_OF_a    64
  21
  22 // a[] is the array in which we do our loads and stores.
  23 // b[] is another one in which we do some copying.
  24 U8 a [SZB_OF_a / 8];    // Type is U8 to ensure it's 8-aligned
  25 U8 b [SZB_OF_a / 8];    // same size as a[]
  26
  27 // XXX: should check the error cases for SET/GET_VBITS also
  28
  29 // For the byte 'x', build a value of 'size' bytes from that byte, eg:
  30 //   size 1 --> x
  31 //   size 2 --> xx
  32 //   size 4 --> xxxx
  33 //   size 8 --> xxxxxxxx
  34 // where the 0 bits are seen by Memcheck as defined, and the 1 bits are
  35 // seen as undefined (ie. the value of each bit matches its V bit, ie. the
  36 // resulting value is the same as its metavalue).
  37 //
  38 U8 build(int size, U1 byte)
  39 {
  40    int i;
  41    U8 mask = 0;
  42    U8 shres;
  43    U8 res = 0xffffffffffffffffULL, res2;
  44    VALGRIND_MAKE_MEM_UNDEFINED(&res, 8);
  45    assert(1 == size || 2 == size || 4 == size || 8 == size);
  46
  47    for (i = 0; i < size; i++) {
  48       mask <<= 8;
  49       mask |= (U8)byte;
  50    }
  51
  52    res &= mask;
  53
  54    // res is now considered partially defined, but we know exactly what its
  55    // value is (it happens to be the same as its metavalue).
  56
  57    (void)VALGRIND_GET_VBITS(&res, &shres, 8);
  58    res2 = res;
  59    (void)VALGRIND_MAKE_MEM_DEFINED(&res2, 8);  // avoid the 'undefined' warning
  60    assert(res2 == shres);
  61    return res;
  62 }
  63
  64 // Check that all the bytes in a[x..y-1] have their V byte equal
  65 // to either 'expected_byte' or 'expected_byte_alt'.
  66 // 'str' and 'offset' are only used for printing an error message if
  67 // something goes wrong.
  68 void check_all(U4 x, U4 y, U1 expected_byte, U1 expected_byte_alt,
  69                            char* str, int offset)
  70 {
  71    U1 sh[SZB_OF_a];     // Used for getting a[]'s V bits
  72    int i;
  73
  74    (void)VALGRIND_GET_VBITS(a, sh, sizeof(a));
  75    for (i = x; i < y; i++) {
  76       if ( expected_byte != sh[i] && expected_byte_alt != sh[i] ) {
  77          fprintf(stderr, "\n\nFAILURE: %s, offset %d, byte %d -- "
  78                          "is 0x%x, should be 0x%x or 0x%x\n\n",
  79                          str, offset, i, sh[i], expected_byte,
  80                          expected_byte_alt);
  81          exit(1);
  82       }
  83    }
  84 }
  85
  86 int main(void)
  87 {
  88    int h, i, j;
  89    U1 *undefA, expected_byte, expected_byte_alt;
  90
  91    if (0 == RUNNING_ON_VALGRIND) {
  92       fprintf(stderr, "error: this program only works when run under Valgrind\n");
  93       exit(1);
  94    }
  95
  96    // Check a[] has the expected alignment, and that it's not too high in
  97    // the address space (which would trigger the slow cases in
  98    // LOADVn/STOREVn) on 64-bit platforms).
  99    assert( 0 == (long)a % 8);
 100    if (sizeof(void*) == 8) {
 101       assert( ((U1*)(&a[0])) < ((U1*)(32ULL * 1024*1024*1024)/*32G*/) );
 102    }
 103
 104    // Check basic types have the expected sizes.
 105    assert(1 == sizeof(U1));
 106    assert(2 == sizeof(U2));
 107    assert(4 == sizeof(U4));
 108    assert(8 == sizeof(U8));
 109
 110    // Create an array of values that has all the possible V bit metavalues.
 111    // Because 0 represents a defined bit, and because undefA[] is initially
 112    // zeroed, we have the nice property that:
 113    //
 114    //    i == undefA[i] == V_bits_of(undefA[i])
 115    //
 116    // which is useful for testing below.
 117    undefA = calloc(1, 256);         // one for each possible undefinedness value
 118    VALGRIND_MAKE_MEM_UNDEFINED(undefA, 256);
 119    for (i = 0; i < 256; i++) {
 120       undefA[i] &= i;
 121    }
 122
 123    // This code does a whole lot of reads and writes of a particular size
 124    // (NNN = 1, 2, 4 or 8), with varying alignments, of values with
 125    // different not/partially/fully defined metavalues, and checks that the
 126    // V bits are set in a[] as expected using GET_VBITS.
 127    //
 128    // 'Ty' is the type of the thing we are copying.  It can be an integer
 129    // type or an FP type.  'ITy' is the same-sized integer type (and thus
 130    // will be the same as 'Ty' if 'ITy' is an integer type).  'ITy' is used
 131    // when doing shifting/masking and stuff like that.
 132
 133 #define DO(NNN, Ty, ITy, isF4) \
 134    fprintf(stderr, "-- NNN: %d %s %s ------------------------\n", NNN, #Ty, #ITy); \
 135    /* For all of the alignments from (0..NNN-1), eg. if NNN==4, we do */ \
 136    /* alignments of 0, 1, 2, 3. */ \
 137    for (h = 0; h < NNN; h++) { \
 138  \
 139       size_t n  = sizeof(a); \
 140       size_t nN = n / sizeof(Ty); \
 141       Ty* aN    = (Ty*)a; \
 142       Ty* bN    = (Ty*)b; \
 143       Ty* aNb   = (Ty*)(((U1*)aN) + h); /* set offset from a[] */ \
 144       Ty* bNb   = (Ty*)(((U1*)bN) + h); /* set offset from b[] */ \
 145  \
 146       fprintf(stderr, "h = %d (checking %d..%d)   ", h, h, (int)(n-NNN+h)); \
 147  \
 148       /* For each of the 256 possible V byte values... */ \
 149       for (j = 0; j < 256; j++) { \
 150          /* build the value for i (one of: i, ii, iiii, iiiiiiii) */ \
 151          U8  tmp        = build(NNN, j); \
 152          ITy undefN_ITy = (ITy)tmp; \
 153          Ty* undefN_Ty; \
 154          { /* This just checks that no overflow occurred when squeezing */ \
 155            /* the output of build() into a variable of type 'Ty'. */ \
 156             U8  tmpDef     = tmp; \
 157             ITy undefN_ITyDef = undefN_ITy; \
 158             VALGRIND_MAKE_MEM_DEFINED(&tmpDef,        8  ); \
 159             VALGRIND_MAKE_MEM_DEFINED(&undefN_ITyDef, NNN); \
 160             assert(tmpDef == (U8)undefN_ITyDef); \
 161          } \
 162  \
 163          /* We have to use an array for undefN_Ty -- because if we try to
 164           * convert an integer type from build into an FP type with a
 165           * straight cast -- eg "float f = (float)i" -- the value gets
 166           * converted.  With this pointer/array nonsense the exact bit
 167           * pattern gets used as an FP value unchanged (that FP value is
 168           * undoubtedly nonsense, but that's not a problem here). */ \
 169          undefN_Ty = (Ty*)&undefN_ITy; \
 170          if (0 == j % 32) fprintf(stderr, "%d...", j); /* progress meter */ \
 171  \
 172  \
 173          /* A nasty exception: most machines so far (x86/PPC32/PPC64)
 174           * don't have 32-bit floats.  So 32-bit floats get cast to 64-bit
 175           * floats.  Memcheck does a PCast in this case, which means that if
 176           * any V bits for the 32-bit float are undefined (ie. 0 != j), all
 177           * the V bits in the 64-bit float are undefined.  So account for
 178           * this when checking.  AMD64 typically does FP arithmetic on
 179           * SSE, effectively giving it access to 32-bit FP registers.  So
 180           * in short, for floats, we have to allow either 'j' or 0xFF
 181           * as an acceptable result.  Sigh. */ \
 182          if (isF4) { \
 183             expected_byte = j; \
 184             expected_byte_alt = 0 != j ? 0xFF : j; \
 185          } else { \
 186             expected_byte = j; \
 187             expected_byte_alt = j; \
 188          } \
 189  \
 190          /* STOREVn.  Note that we use the first element of the undefN_Ty
 191           * array, as explained above. */ \
 192          for (i = 0; i < nN-1; i++) { aNb[i] = undefN_Ty[0]; } \
 193          check_all(h, n-NNN+h, expected_byte, expected_byte_alt, "STOREVn", h); \
 194  \
 195          /* LOADVn -- by copying the values to one place and then back,
 196           * we ensure that LOADVn gets exercised. */ \
 197          for (i = 0; i < nN-1; i++) { bNb[i] = aNb[i]; } \
 198          for (i = 0; i < nN-1; i++) { aNb[i] = bNb[i]; } \
 199          check_all(h, n-NNN+h, expected_byte, expected_byte_alt, "LOADVn", h); \
 200       } \
 201       fprintf(stderr, "\n"); \
 202    }
 203
 204    // For sizes 4 and 8 we do both integer and floating-point types.  The
 205    // reason being that on 32-bit machines just using integer types never
 206    // exercises LOADV8/STOREV8 -- for integer types these loads/stores get
 207    // broken into two 32-bit loads/stores.
 208    DO(1, U1, U1, /*isF4*/0);
 209    DO(2, U2, U2, /*isF4*/0);
 210    DO(4, U4, U4, /*isF4*/0);
 211    DO(4, F4, U4, /*isF4*/1);
 212    DO(8, U8, U8, /*isF4*/0);
 213    DO(8, F8, U8, /*isF4*/0);
 214
 215    return 0;
 216 }