Home | History | Annotate | Download | only in tests
      1 
      2 /* This test case was originally written by Nicholas Nethercote. */
      3 
      4 // This test covers all the different sources of values, both defined and
      5 // undefined.  It only involves undefined condition errors.
      6 //
      7 // Nb: a stack frame is allocated when a signal is delivered.  But it
      8 // immediately get written with stuff, so there's no significant possibility
      9 // of undefined values originating there.  So we ignore it.  (On platforms
     10 // like AMD64 that have a redzone just beyond the stack pointer there is a
     11 // possibility, but it's so slim we ignore it.)
     12 
     13 #include <stdio.h>
     14 #include <assert.h>
     15 #include <stdlib.h>
     16 #include "tests/sys_mman.h"
     17 #include <unistd.h>
     18 #include "../memcheck.h"
     19 
     20 int x = 0;
     21 
     22 int main(void)
     23 {
     24    assert(1 == sizeof(char));
     25    assert(2 == sizeof(short));
     26    assert(4 == sizeof(int));
     27    assert(8 == sizeof(long long));
     28 
     29    //------------------------------------------------------------------------
     30    // Sources of undefined values
     31    //------------------------------------------------------------------------
     32 
     33    // Stack, 32-bit
     34    {
     35       volatile int undef_stack_int;
     36       fprintf(stderr, "\nUndef 1 of 8 (stack, 32 bit)\n");
     37       x += (undef_stack_int == 0x12345678 ? 10 : 21);
     38    }
     39 
     40    // Stack, 32-bit, recently modified.  Nb: we have to do the register
     41    // mucking about to make sure that the modification isn't fenced by a
     42    // store/load pair and thus not seen (see origin-not-quite.c).
     43    {
     44       volatile int undef_stack_int;
     45       register int modified_undef_stack_int;
     46       fprintf(stderr, "\nUndef 2 of 8 (stack, 32 bit)\n");
     47       modified_undef_stack_int = undef_stack_int;
     48       modified_undef_stack_int++;
     49       x += (modified_undef_stack_int == 0x1234 ? 11 : 22);
     50    }
     51 
     52    // Stack, 64-bit.  XXX: gets reported with two identical origins.
     53    {
     54       volatile long long undef_stack_longlong;
     55       fprintf(stderr, "\nUndef 3 of 8 (stack, 64 bit)\n");
     56       x += (undef_stack_longlong == 0x1234567812345678LL ? 11 : 22);
     57    }
     58 
     59    // Malloc block, uninitialised, 32-bit
     60    {
     61       int* ptr_to_undef_malloc_int = malloc(sizeof(int));
     62       int  undef_malloc_int = *ptr_to_undef_malloc_int;
     63       fprintf(stderr, "\nUndef 4 of 8 (mallocd, 32-bit)\n");
     64       x += (undef_malloc_int == 0x12345678 ? 12 : 23);
     65    }
     66 
     67    // Realloc block, uninitialised
     68    {
     69       int* ptr_to_undef_malloc_int2 = malloc(sizeof(int));
     70          // Allocate a big chunk to ensure that a new block is allocated.
     71       int* ptr_to_undef_realloc_int = realloc(ptr_to_undef_malloc_int2, 4096);
     72          // Have to move past the first 4 bytes, which were copied from the
     73          // malloc'd block.
     74       int  undef_realloc_int = *(ptr_to_undef_realloc_int+1);
     75       fprintf(stderr, "\nUndef 5 of 8 (realloc)\n");
     76       x += (undef_realloc_int == 0x12345678 ? 13 : 24);
     77    }
     78 
     79    // Custom-allocated block, non-zeroed
     80    {
     81       int  undef_custom_alloc_int;
     82       VALGRIND_MALLOCLIKE_BLOCK(&undef_custom_alloc_int, sizeof(int),
     83                                 /*rzB*/0, /*is_zeroed*/0);
     84       fprintf(stderr, "\nUndef 6 of 8 (MALLOCLIKE_BLOCK)\n");
     85       x += (undef_custom_alloc_int == 0x12345678 ? 14 : 25);
     86    }
     87 
     88    // Heap segment (brk), uninitialised
     89    // CURRENTLY DISABLED.  Why?
     90    // - On Darwin, sbrk() is implemented via vm_allocate() which always zeroes
     91    //   its allocated memory.  For a while we used use a separate .exp file
     92    //   for Darwin, but we add an extra printf on Darwin only so that it
     93    //   cannot be successfully matched on non-Darwin platforms.
     94    // - On Ubuntu 9.04 configured with --enable-only32bit, the brk symbol
     95    //   shows up as "???"
     96    // - Our current treatment of brk is suspect;  whole new pages allocated
     97    //   with brk should arguably be marked defined -- see the big comment
     98    //   above track_new_mem_brk() in memcheck/mc_main.c.
     99 //#if defined(VGO_darwin)
    100       fprintf(stderr, "\nUndef 7 of 8 (brk)\n");
    101 //      fprintf(stderr, "\n(no complaint; sbrk initialises memory on Darwin)\n");
    102       fprintf(stderr, "\n(currently disabled)\n");
    103 //#else
    104 //   {
    105 //      int* ptr_to_new_brk_limit = sbrk(4096);
    106 //      int  undef_brk_int = *ptr_to_new_brk_limit;
    107 //      fprintf(stderr, "\nUndef 7 of 8 (brk)\n");
    108 //      x += (undef_brk_int == 0x12345678 ? 15 : 26);
    109 //   }
    110 //#endif
    111 
    112    // User block, marked as undefined
    113    {
    114       int  undef_user_int = 0;
    115       VALGRIND_MAKE_MEM_UNDEFINED(&undef_user_int, sizeof(int));
    116       fprintf(stderr, "\nUndef 8 of 8 (MAKE_MEM_UNDEFINED)\n");
    117       x += (undef_user_int == 0x12345678 ? 16 : 27);
    118    }
    119 
    120    //------------------------------------------------------------------------
    121    // Sources of defined values
    122    //------------------------------------------------------------------------
    123 
    124    // Heap block (calloc), initialised
    125    {
    126       int* ptr_to_def_calloc_int = calloc(1, sizeof(int));
    127       int  def_calloc_int = *ptr_to_def_calloc_int;
    128       fprintf(stderr, "\nDef 1 of 3\n");
    129       x += (def_calloc_int == 0x12345678 ? 17 : 28);
    130    }
    131 
    132    // Custom-allocated block, non-zeroed
    133    {
    134       int  def_custom_alloc_int = 0;
    135       fprintf(stderr, "\nDef 2 of 3\n");
    136       VALGRIND_MALLOCLIKE_BLOCK(&def_custom_alloc_int, sizeof(int),
    137                                 /*rzB*/0, /*is_zeroed*/1);
    138       x += (def_custom_alloc_int == 0x12345678 ? 18 : 29);
    139    }
    140 
    141    // mmap block, initialised
    142    {
    143       int* ptr_to_def_mmap_int =
    144                mmap(0, 4096, PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    145       int def_mmap_int = *ptr_to_def_mmap_int;
    146       fprintf(stderr, "\nDef 3 of 3\n");
    147       x += (def_mmap_int == 0x12345678 ? 19 : 30);
    148    }
    149 
    150    return x;
    151 }
    152