memcheck/tests/sh-mem-random.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 "tests/sys_mman.h"
   9 #include "memcheck/memcheck.h"
  10
  11 // All the sizes here are in *bytes*, not bits.
  12
  13 typedef unsigned char        U1;
  14 typedef unsigned short       U2;
  15 typedef unsigned int         U4;
  16 typedef unsigned long long   U8;
  17
  18 typedef float                F4;
  19 typedef double               F8;
  20
  21 typedef unsigned long        UWord;
  22
  23 #define PAGE_SIZE 4096ULL
  24
  25
  26 // XXX: should check the error cases for SET/GET_VBITS also
  27
  28 // For the byte 'x', build a value of 'size' bytes from that byte, eg:
  29 //   size 1 --> x
  30 //   size 2 --> xx
  31 //   size 4 --> xxxx
  32 //   size 8 --> xxxxxxxx
  33 // where the 0 bits are seen by Memcheck as defined, and the 1 bits are
  34 // seen as undefined (ie. the value of each bit matches its V bit, ie. the
  35 // resulting value is the same as its metavalue).
  36 //
  37 U8 build(int size, U1 byte)
  38 {
  39    int i;
  40    U8 mask = 0;
  41    U8 shres;
  42    U8 res = 0xffffffffffffffffULL, res2;
  43    (void)VALGRIND_MAKE_MEM_UNDEFINED(&res, 8);
  44    assert(1 == size || 2 == size || 4 == size || 8 == size);
  45
  46    for (i = 0; i < size; i++) {
  47       mask <<= 8;
  48       mask |= (U8)byte;
  49    }
  50
  51    res &= mask;
  52
  53    // res is now considered partially defined, but we know exactly what its
  54    // value is (it happens to be the same as its metavalue).
  55
  56    (void)VALGRIND_GET_VBITS(&res, &shres, 8);
  57    res2 = res;
  58    (void)VALGRIND_MAKE_MEM_DEFINED(&res2, 8);  // avoid the 'undefined' warning
  59    assert(res2 == shres);
  60    return res;
  61 }
  62
  63 U1 make_defined ( U1 x )
  64 {
  65    volatile U1 xx = x;
  66    (void)VALGRIND_MAKE_MEM_DEFINED(&xx, 1);
  67    return xx;
  68 }
  69
  70 void check(U1* arr, int n, char* who)
  71 {
  72    int i;
  73    U1* shadow = malloc(n);
  74    U1 arr_i;
  75    U8 sum = 0;
  76    (void)VALGRIND_GET_VBITS(arr, shadow, n);
  77    for (i = 0; i < n; i++) {
  78       arr_i = make_defined(arr[i]);
  79       if (arr_i != shadow[i]) {
  80           fprintf(stderr, "\n\nFAILURE: %s, byte %d -- "
  81                           "is 0x%x, should be 0x%x\n\n",
  82                           who, i, shadow[i], arr[i]);
  83           exit(1);
  84       }
  85       sum += (U8)arr_i;
  86    }
  87    free(shadow);
  88    printf("test passed, sum = %llu (%9.5f per byte)\n",
  89           sum, (F8)sum / (F8)n);
  90 }
  91
  92 static inline U4 randomU4 ( void )
  93 {
  94    static U4 n = 0;
  95    /* From "Numerical Recipes in C" 2nd Edition */
  96    n = 1664525UL * n + 1013904223UL;
  97    return n;
  98 }
  99
 100 static inline U1 randomU1 ( void )
 101 {
 102    return 0xFF & (randomU4() >> 13);
 103 }
 104
 105 #define N_BYTES  300000
 106 #define N_EVENTS (5 * N_BYTES)
 107
 108
 109 void do_test_at ( U1* arr )
 110 {
 111    int i;
 112
 113    U4 mv1 = 0, mv2 = 0, mv4 = 0, mv8 = 0, mv4f = 0, mv8f = 0;
 114
 115    /* Fill arr with random bytes whose shadows match them. */
 116    if (0) printf("-------- arr = %p\n", arr);
 117
 118    printf("initialising\n");
 119    for (i = 0; i < N_BYTES; i++)
 120       arr[i] = (U1)build(1, randomU1());
 121
 122    printf("post-initialisation check\n");
 123    check(arr, N_BYTES, "after initialisation");
 124
 125    /* Now do huge numbers of memory copies. */
 126    printf("doing copies\n");
 127    for (i = 0; i < N_EVENTS; i++) {
 128       U4 ty, src, dst;
 129       ty  = (randomU4() >> 13) % 5;
 130      tryagain:
 131       src = (randomU4() >>  1) % N_BYTES;
 132       dst = (randomU4() >>  3) % N_BYTES;
 133       switch (ty) {
 134          case 0: { // U1
 135             *(U1*)(arr+dst) = *(U1*)(arr+src);
 136             mv1++;
 137             break;
 138          }
 139          case 1: { // U2
 140             if (src+2 >= N_BYTES || dst+2 >= N_BYTES)
 141                goto tryagain;
 142             *(U2*)(arr+dst) = *(U2*)(arr+src);
 143             mv2++;
 144             break;
 145          }
 146          case 2: { // U4
 147             if (src+4 >= N_BYTES || dst+4 >= N_BYTES)
 148                goto tryagain;
 149             *(U4*)(arr+dst) = *(U4*)(arr+src);
 150             mv4++;
 151             break;
 152          }
 153          case 3: { // U8
 154             if (src+8 >= N_BYTES || dst+8 >= N_BYTES)
 155                goto tryagain;
 156             *(U8*)(arr+dst) = *(U8*)(arr+src);
 157             mv8++;
 158             break;
 159          }
 160          /* Don't bother with 32-bit floats.  These cause
 161             horrible complications, as discussed in sh-mem.c. */
 162          /*
 163          case 4: { // F4
 164             if (src+4 >= N_BYTES || dst+4 >= N_BYTES)
 165                goto tryagain;
 166             *(F4*)(arr+dst) = *(F4*)(arr+src);
 167             mv4f++;
 168             break;
 169          }
 170          */
 171          case 4: { // F8
 172             if (src+8 >= N_BYTES || dst+8 >= N_BYTES)
 173                goto tryagain;
 174 #if defined(__i386__)
 175             /* Copying via an x87 register causes the test to fail,
 176                because (I think) some obscure values that are FP
 177                denormals get changed during the copy due to the FPU
 178                normalising, or rounding, or whatever, them.  This
 179                causes them to no longer bit-for-bit match the
 180                accompanying metadata.  Yet we still need to do a
 181                genuine 8-byte load/store to test the relevant memcheck
 182                {LOADV8,STOREV8} routines.  Hence use the MMX registers
 183                instead, as copying through them should be
 184                straightforward.. */
 185             __asm__ __volatile__(
 186                "movq (%1), %%mm2\n\t"
 187                "movq %%mm2, (%0)\n\t"
 188                "emms"
 189                : : "r"(arr+dst), "r"(arr+src) : "memory"
 190             );
 191 #else
 192             /* Straightforward.  On amd64, this gives a load/store of
 193                the bottom half of an xmm register.  On ppc32/64 this
 194                is a straighforward load/store of an FP register. */
 195             *(F8*)(arr+dst) = *(F8*)(arr+src);
 196 #endif
 197             mv8f++;
 198             break;
 199          }
 200          default:
 201            fprintf(stderr, "sh-mem-random: bad size\n");
 202            exit(0);
 203       }
 204    }
 205
 206    printf("final check\n");
 207    check(arr, N_BYTES, "final check");
 208
 209    printf("counts 1/2/4/8/F4/F8: %d %d %d %d %d %d\n",
 210           mv1, mv2, mv4, mv8, mv4f, mv8f);
 211 }
 212
 213
 214
 215 int main(void)
 216 {
 217    U1* arr;
 218
 219    if (0 == RUNNING_ON_VALGRIND) {
 220       fprintf(stderr, "error: this program only works when run under Valgrind\n");
 221       exit(1);
 222    }
 223
 224    printf("-------- testing non-auxmap range --------\n");
 225
 226    arr = malloc(N_BYTES);
 227    assert(arr);
 228    do_test_at(arr);
 229    free(arr);
 230
 231    if (sizeof(void*) == 8) {
 232       // 64-bit platform.
 233       int tries;
 234       int nbytes_p;
 235       // (U1*)(UWord)constULL funny casting to keep gcc quiet on
 236       // 32-bit platforms
 237       U1* huge_addr = (U1*)(UWord)0x6600000000ULL;  // 408GB
 238       // Note, kernel 2.6.? on Athlon64 refuses fixed mmap requests
 239       // at above 512GB.
 240
 241       printf("-------- testing auxmap range --------\n");
 242
 243       nbytes_p = (N_BYTES + PAGE_SIZE) & ~(PAGE_SIZE-1);
 244
 245       for (tries = 0; tries < 10; tries++) {
 246          arr = mmap(huge_addr, nbytes_p, PROT_READ|PROT_WRITE,
 247                     MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1,0);
 248          if (arr != MAP_FAILED)
 249             break;
 250          // hmm. fudge the address and try again.
 251          huge_addr += (randomU4() & ~(PAGE_SIZE-1));
 252       }
 253
 254       if (tries >= 10) {
 255            fprintf(stderr, "sh-mem-random: can't mmap hi-mem\n");
 256            exit(0);
 257       }
 258       assert(arr != MAP_FAILED);
 259
 260       do_test_at(arr);
 261    }
 262
 263    return 0;
 264
 265 }