memcheck/tests/origin1-yes.c

   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       (void) 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 }