Silence clang warnings about uninitialised and unused values in

memcheck testcases.


git-svn-id: svn://svn.valgrind.org/valgrind/trunk@13599

memcheck/mc_replace_strmem.c

@@ -1796,7 +1796,7 @@ int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, setenv)
     if (value)
         for (p = value; *p; p++)
             __asm__ __volatile__("" ::: "memory");
-    VALGRIND_CHECK_VALUE_IS_DEFINED (overwrite);
+    (void) VALGRIND_CHECK_VALUE_IS_DEFINED (overwrite);
     CALL_FN_W_WWW(result, fn, name, value, overwrite);
     return result;
 }

memcheck/tests/Makefile.am

@@ -385,6 +385,8 @@ execve1_CFLAGS = $(AM_CFLAGS) @FLAG_W_NO_NONNULL@
 
 execve2_CFLAGS = $(AM_CFLAGS) @FLAG_W_NO_NONNULL@
 
+fprw_CFLAGS = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
+
 inits_CFLAGS = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
 
 long_namespace_xml_SOURCES = long_namespace_xml.cpp
@@ -398,6 +400,8 @@ mismatches_SOURCES	= mismatches.cpp
 new_nothrow_SOURCES 	= new_nothrow.cpp
 new_override_SOURCES 	= new_override.cpp
 
+origin1_yes_CFLAGS      = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
+
 origin2_not_quite_CFLAGS = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
 
 origin3_no_CFLAGS = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
@@ -415,9 +419,16 @@ overlap_CFLAGS		= $(AM_CFLAGS) -fno-builtin-memcpy -fno-builtin-strcpy
 
 str_tester_CFLAGS	= $(AM_CFLAGS) -Wno-shadow
 
+supp_CFLAGS             = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
+
 supp_unknown_SOURCES	= badjump.c
+supp_unknown_CFLAGS     = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
+
 supp1_SOURCES		= supp.c
+supp1_CFLAGS            = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
+
 supp2_SOURCES		= supp.c
+supp2_CFLAGS            = $(AM_CFLAGS) @FLAG_W_NO_UNINITIALIZED@
 
 vcpu_bz2_CFLAGS		= $(AM_CFLAGS) -O2
 vcpu_fbench_CFLAGS	= $(AM_CFLAGS) -O2

memcheck/tests/addressable.c

@@ -34,18 +34,18 @@ static void test1()
 {
 	char *m = mm(0, pgsz * 5, PROT_READ);
 
-	VALGRIND_CHECK_MEM_IS_DEFINED(m, pgsz*5); /* all defined */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m, pgsz*5); /* all defined */
 }
 
 /* Case 2 - unmapped memory is unaddressable+undefined */
 static void test2()
 {
 	char *m = mm(0, pgsz * 5, PROT_READ|PROT_WRITE);
-	VALGRIND_CHECK_MEM_IS_DEFINED(m, pgsz*5); /* all OK */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m, pgsz*5); /* all OK */
 
 	munmap(&m[pgsz*2], pgsz);
 
-	VALGRIND_CHECK_MEM_IS_DEFINED(&m[pgsz*2], pgsz); /* undefined */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(&m[pgsz*2], pgsz); /* undefined */
 
 	/* XXX need a memcheck request to test addressability */
 	m[pgsz*2] = 'x';	/* unmapped fault */
@@ -56,9 +56,9 @@ static void test3()
 {
 	char *m = mm(0, pgsz * 5, PROT_READ|PROT_WRITE);
 
-	VALGRIND_MAKE_MEM_UNDEFINED(&m[pgsz], pgsz);
+	(void) VALGRIND_MAKE_MEM_UNDEFINED(&m[pgsz], pgsz);
 	mm(&m[pgsz], pgsz, PROT_READ);
-	VALGRIND_CHECK_MEM_IS_DEFINED(&m[pgsz], pgsz); /* OK */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(&m[pgsz], pgsz); /* OK */
 }
 
 /* Case 4 - mprotect doesn't affect addressability */
@@ -67,7 +67,7 @@ static void test4()
 	char *m = mm(0, pgsz * 5, PROT_READ|PROT_WRITE);
 
 	mprotect(m, pgsz, PROT_WRITE);
-	VALGRIND_CHECK_MEM_IS_DEFINED(m, pgsz); /* OK */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m, pgsz); /* OK */
 	m[44] = 'y';		/* OK */
 
 	mprotect(m, pgsz*5, PROT_NONE);
@@ -79,16 +79,16 @@ static void test5()
 {
 	char *m = mm(0, pgsz * 5, PROT_READ|PROT_WRITE);
 	
-	VALGRIND_MAKE_MEM_UNDEFINED(m, pgsz*5);
+	(void) VALGRIND_MAKE_MEM_UNDEFINED(m, pgsz*5);
 	memset(m, 'x', 10);
-	VALGRIND_CHECK_MEM_IS_DEFINED(m, 10);	/* OK */
-	VALGRIND_CHECK_MEM_IS_DEFINED(m+10, 10); /* BAD */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m, 10);	/* OK */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m+10, 10); /* BAD */
 
 	mprotect(m, pgsz*5, PROT_NONE);
 	mprotect(m, pgsz*5, PROT_READ);
 
-	VALGRIND_CHECK_MEM_IS_DEFINED(m, 10);	/* still OK */
-	VALGRIND_CHECK_MEM_IS_DEFINED(m+20, 10); /* BAD */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m, 10);	/* still OK */
+	(void) VALGRIND_CHECK_MEM_IS_DEFINED(m+20, 10); /* BAD */
 }
 
 static struct test {

memcheck/tests/clientperm.c

@@ -7,7 +7,7 @@
 int main1 ( void )
 {
   int xxx, i;
-  for (i = 0; i < 10; i++) VALGRIND_CHECK_VALUE_IS_DEFINED(xxx);
+  for (i = 0; i < 10; i++) (void) VALGRIND_CHECK_VALUE_IS_DEFINED(xxx);
   return 0;
 }
 
@@ -17,10 +17,10 @@ int main ( void )
    char* aa = calloc(100,1);
    sum = 0;
 
-   VALGRIND_CHECK_MEM_IS_DEFINED(aa,100);
+   (void) VALGRIND_CHECK_MEM_IS_DEFINED(aa,100);
 
    m = VALGRIND_MAKE_MEM_UNDEFINED( &aa[49], 1 );
-   VALGRIND_CHECK_MEM_IS_ADDRESSABLE(aa,100);
+   (void) VALGRIND_CHECK_MEM_IS_ADDRESSABLE(aa,100);
 
    printf("m_na: returned value is %d\n", m );
 

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

@@ -66,7 +66,7 @@ static inline U1 randomU1 ( void )
 static inline U1 self_shadow ( U1 x )
 {
    U1 res = 0xFF;
-   VALGRIND_MAKE_MEM_UNDEFINED(&res, 1);
+   (void) VALGRIND_MAKE_MEM_UNDEFINED(&res, 1);
    res &= x;
    return res;
 }
@@ -82,20 +82,20 @@ static inline U1 get_shadow ( U1 x )
 static inline U1 make_def ( U1 x )
 {
    U1 y = x;
-   VALGRIND_MAKE_MEM_DEFINED(&y, 1);
+   (void) VALGRIND_MAKE_MEM_DEFINED(&y, 1);
    return y;
 }
 
 static inline U1 make_undef ( U1 x )
 {
    U1 y = x;
-   VALGRIND_MAKE_MEM_UNDEFINED(&y, 1);
+   (void) VALGRIND_MAKE_MEM_UNDEFINED(&y, 1);
    return y;
 }
 
 static void make_noaccess ( U1* dst )
 {
-   VALGRIND_MAKE_MEM_NOACCESS(dst, 1);
+  (void) VALGRIND_MAKE_MEM_NOACCESS(dst, 1);
 }
 
 static void apply ( void(*fn)(U4,Bool), U4 arg1, Bool arg2 )

memcheck/tests/cond_ld_st.c

@@ -32,12 +32,12 @@ typedef  unsigned char  Bool;
 
 static void make_undef ( void* addr, size_t len )
 {
-   VALGRIND_MAKE_MEM_UNDEFINED(addr, len);
+  (void) VALGRIND_MAKE_MEM_UNDEFINED(addr, len);
 }
 
 static void make_def ( void* addr, size_t len )
 {
-   VALGRIND_MAKE_MEM_DEFINED(addr, len);
+  (void) VALGRIND_MAKE_MEM_DEFINED(addr, len);
 }
 
 // Returns either |*src| or |alt|.

memcheck/tests/custom_alloc.c

@@ -22,7 +22,7 @@ void* get_superblock(void)
    // program to be using it unless its handed out by custom_alloc()
 
    // with redzones, better not to have it
-   VALGRIND_MAKE_MEM_NOACCESS(p, SUPERBLOCK_SIZE);
+   (void) VALGRIND_MAKE_MEM_NOACCESS(p, SUPERBLOCK_SIZE);
 
    return p;
 }
@@ -122,7 +122,7 @@ int main(void)
 
    // Make the entire array defined again such that it can be verified whether
    // the red zone is marked properly when resizing in place.
-   VALGRIND_MAKE_MEM_DEFINED(array, sizeof(int) * 10);
+   (void) VALGRIND_MAKE_MEM_DEFINED(array, sizeof(int) * 10);
 
    VALGRIND_RESIZEINPLACE_BLOCK(array, sizeof(int) * 5, sizeof(int) * 7, RZ);
    if (array[5]) array[4]++; // uninitialized read of array[5]

memcheck/tests/describe-block.c

@@ -3,8 +3,8 @@
 int main()
 {
    char magic_foople_zone[0x1000];
-   VALGRIND_CREATE_BLOCK(magic_foople_zone, 0x1000, "magic foople zone");
-   VALGRIND_MAKE_MEM_NOACCESS(magic_foople_zone, 0x1000);
+   (void) VALGRIND_CREATE_BLOCK(magic_foople_zone, 0x1000, "magic foople zone");
+   (void) VALGRIND_MAKE_MEM_NOACCESS(magic_foople_zone, 0x1000);
    magic_foople_zone[0] = 'x';
    return 0;
 }

memcheck/tests/dw4.c

@@ -24,7 +24,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }

memcheck/tests/holey_buffer_too_small.c

@@ -18,25 +18,25 @@ int main ( void )
    fprintf(stderr, "\n---- part defined, address error at end ----\n\n");
    a = malloc(8);
    a[0] = a[1] = a[2] = a[3] = a[6] = a[7] = 'x';
-   VALGRIND_CHECK_MEM_IS_DEFINED(a, 9);
+   (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 9);
    free(a);
 
    fprintf(stderr, "\n---- part defined, address error at start ----\n\n");
    a = malloc(8);
    a[0] = a[1] = a[2] = a[3] = a[6] = a[7] = 'x';
-   VALGRIND_CHECK_MEM_IS_DEFINED(a-1, 9);
+   (void) VALGRIND_CHECK_MEM_IS_DEFINED(a-1, 9);
    free(a);
 
    fprintf(stderr, "\n---- fully defined, address error at end ----\n\n");
    a = malloc(8);
    a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = 'x';
-   VALGRIND_CHECK_MEM_IS_DEFINED(a, 9);
+   (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 9);
    free(a);
 
    fprintf(stderr, "\n---- fully defined, address error at start ----\n\n");
    a = malloc(8);
    a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = 'x';
-   VALGRIND_CHECK_MEM_IS_DEFINED(a-1, 9);
+   (void) VALGRIND_CHECK_MEM_IS_DEFINED(a-1, 9);
    free(a);
 
    return 0;

memcheck/tests/leak-pool.c

@@ -40,7 +40,7 @@ allocate_pool()
   assert(p->buf);
   memset(p->buf, 0, p->allocated);
   VALGRIND_CREATE_MEMPOOL(p, 0, 0);
-  VALGRIND_MAKE_MEM_NOACCESS(p->buf, p->allocated);
+  (void) VALGRIND_MAKE_MEM_NOACCESS(p->buf, p->allocated);
   return p;
 }
 

memcheck/tests/leak-segv-jmp.c

@@ -200,13 +200,13 @@ void f(void)
    VALGRIND_DO_LEAK_CHECK;
 
    // make b10[4000] undefined. This should create a leak.
-   VALGRIND_MAKE_MEM_UNDEFINED (&b10[4000], sizeof(char*));
+   (void) VALGRIND_MAKE_MEM_UNDEFINED (&b10[4000], sizeof(char*));
    fprintf(stderr, "expecting a leak\n");
    fflush(stderr);
    VALGRIND_DO_LEAK_CHECK;
 
    // make  b10[4000] defined again.
-   VALGRIND_MAKE_MEM_DEFINED (&b10[4000], sizeof(char*));
+   (void) VALGRIND_MAKE_MEM_DEFINED (&b10[4000], sizeof(char*));
 
    // now make some bricolage to have some pages around b10[4000]
    // unreadable. The leak check should recover from that
@@ -222,7 +222,7 @@ void f(void)
       perror ("sysconf failed");
    
    if (RUNNING_ON_VALGRIND)
-      VALGRIND_NON_SIMD_CALL2(non_simd_mprotect, RNDPAGEDOWN(&b10[4000]), 2 * pagesize);
+     (void) VALGRIND_NON_SIMD_CALL2(non_simd_mprotect, RNDPAGEDOWN(&b10[4000]), 2 * pagesize);
    else
       mprotect_result = mprotect((void*) RNDPAGEDOWN(&b10[4000]), 2 * pagesize, PROT_NONE);
    fprintf(stderr, "mprotect result %d\n", mprotect_result);

memcheck/tests/leak_cpp_interior.cpp

@@ -96,18 +96,18 @@ void doit(void)
 int main() { 
 
    doit();
-   VALGRIND_MONITOR_COMMAND("v.set log_output");
+   (void) VALGRIND_MONITOR_COMMAND("v.set log_output");
 
    fprintf(stderr, "VALGRIND_DO_LEAK_CHECK\n");
    VALGRIND_DO_LEAK_CHECK; // All possible leaks should be detected, giving only reachable data.
 
    // Check individually each heuristic
    fprintf(stderr, "leak_check summary heuristics multipleinheritance\n");
-   VALGRIND_MONITOR_COMMAND("leak_check summary heuristics multipleinheritance");
+   (void) VALGRIND_MONITOR_COMMAND("leak_check summary heuristics multipleinheritance");
    fprintf(stderr, "leak_check summary any heuristics newarray\n");
-   VALGRIND_MONITOR_COMMAND("leak_check summary heuristics newarray");
+   (void) VALGRIND_MONITOR_COMMAND("leak_check summary heuristics newarray");
    fprintf(stderr, "leak_check summary heuristics stdstring\n");
-   VALGRIND_MONITOR_COMMAND("leak_check summary heuristics stdstring");
+   (void) VALGRIND_MONITOR_COMMAND("leak_check summary heuristics stdstring");
 
    delete [] ptr;
    delete [] ptr2;

memcheck/tests/malloc_free_fill.c

@@ -12,7 +12,7 @@ int main ( void )
   int *r, *oldr, *a;
 
 #define TEST(x, exp_x, desc) \
-  VALGRIND_MAKE_MEM_DEFINED(&x, sizeof(int)); \
+  (void)VALGRIND_MAKE_MEM_DEFINED(&x, sizeof(int));     \
   if (x == exp_x) { \
      fprintf(stderr, "PASSED: " desc "\n"); \
   } else { \

memcheck/tests/match-overrun.c

@@ -5,7 +5,7 @@
 static int a1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789(void)
 {
   int x;
-  VALGRIND_MAKE_MEM_NOACCESS(&x, sizeof(x));
+  (void) VALGRIND_MAKE_MEM_NOACCESS(&x, sizeof(x));
   return *(int *)&x;
 }
 

memcheck/tests/mempool.c

@@ -46,7 +46,7 @@ pool *make_pool()
 
    p->size = p->left = SUPERBLOCK_SIZE;
    p->levels = NULL;
-   VALGRIND_MAKE_MEM_NOACCESS(p->where, SUPERBLOCK_SIZE);
+   (void) VALGRIND_MAKE_MEM_NOACCESS(p->where, SUPERBLOCK_SIZE);
    return p;
 }
 
@@ -72,7 +72,7 @@ void pop(pool *p)
    level_list *l = p->levels;
    p->levels = l->next;
    VALGRIND_DESTROY_MEMPOOL(l->where);
-   VALGRIND_MAKE_MEM_NOACCESS(l->where, p->where-l->where);
+   (void) VALGRIND_MAKE_MEM_NOACCESS(l->where, p->where-l->where);
    p->where = l->where;
    if(USE_MMAP)
       munmap(l, sizeof(level_list));

memcheck/tests/mempool2.c

@@ -49,7 +49,7 @@ pool *make_pool( int use_mmap )
 
    p->size = p->left = SUPERBLOCK_SIZE;
    p->levels = NULL;
-   VALGRIND_MAKE_MEM_NOACCESS(p->where, SUPERBLOCK_SIZE);
+   (void) VALGRIND_MAKE_MEM_NOACCESS(p->where, SUPERBLOCK_SIZE);
    return p;
 }
 
@@ -75,7 +75,7 @@ void pop(pool *p, int use_mmap)
    level_list *l = p->levels;
    p->levels = l->next;
    VALGRIND_DESTROY_MEMPOOL(l->where);
-   VALGRIND_MAKE_MEM_NOACCESS(l->where, p->where-l->where);
+   (void) VALGRIND_MAKE_MEM_NOACCESS(l->where, p->where-l->where);
    p->where = l->where;
    if (use_mmap)
       munmap(l, sizeof(level_list));

memcheck/tests/origin1-yes.c

@@ -112,7 +112,7 @@ int main(void)
    // User block, marked as undefined
    {
       int  undef_user_int = 0;
-      VALGRIND_MAKE_MEM_UNDEFINED(&undef_user_int, sizeof(int));
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(&undef_user_int, sizeof(int));
       fprintf(stderr, "\nUndef 8 of 8 (MAKE_MEM_UNDEFINED)\n");
       x += (undef_user_int == 0x12345678 ? 16 : 27);
    }

memcheck/tests/origin3-no.c

@@ -101,8 +101,8 @@ __attribute__((noinline)) int t6(void)
    {
       int* ptr_to_3_undef_ints = calloc(3, sizeof(int));
       int* ptr_to_middle       = (int*)((long)ptr_to_3_undef_ints + 6);
-      VALGRIND_MAKE_MEM_UNDEFINED(ptr_to_3_undef_ints, 6);
-      VALGRIND_MAKE_MEM_UNDEFINED(ptr_to_middle,       6);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(ptr_to_3_undef_ints, 6);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(ptr_to_middle,       6);
       fprintf(stderr, "\nUndef 6 of 8 (32 bit undef, unaligned, strange, #1)\n");
       y += (*(ptr_to_3_undef_ints + 0)  == 0x12345678 ? 16 : 27);
       fprintf(stderr, "\nUndef 7 of 8 (32 bit undef, unaligned, strange, #2)\n");

memcheck/tests/origin5-bz2.c

@@ -6476,7 +6476,7 @@ int main ( int argc, char** argv )
 
    /* Make inbuf[10] be undefined, so as to check that this source
       eventually shows up in various places. */
-   VALGRIND_MAKE_MEM_UNDEFINED(&inbuf[10], sizeof(char));
+   (void) VALGRIND_MAKE_MEM_UNDEFINED(&inbuf[10], sizeof(char));
 
    if (inbuf[10] == 11) vex_printf("foo\n"); else vex_printf("bar\n");
 

memcheck/tests/origin6-fp.c

@@ -72,7 +72,7 @@ void setup_arr ( /*OUT*/double** arr, int nArr )
       arr[i][j] = (double)(i * j);
       if (i == nArr/2 && j == nArr/2) {
          unsigned char* p = (unsigned char*)&arr[i][j];
-         VALGRIND_MAKE_MEM_UNDEFINED(p, 1);
+         (void) VALGRIND_MAKE_MEM_UNDEFINED(p, 1);
       }
     }
   }

memcheck/tests/pointer-trace.c

@@ -74,7 +74,7 @@ int main()
 		perror("trap 4 failed");
 	else {
 		munmap(map, 256*1024);
-		VALGRIND_MAKE_MEM_DEFINED(map, 256*1024); /* great big fat lie */
+		(void)VALGRIND_MAKE_MEM_DEFINED(map, 256*1024); /* great big fat lie */
 	}
 
 	VALGRIND_DO_LEAK_CHECK;

memcheck/tests/post-syscall.c

@@ -31,7 +31,7 @@ int main()
 	if (ret != -1 || errno != EINTR) {
 		fprintf(stderr, "FAILED: expected nanosleep to be interrupted\n");
 	} else {
-		VALGRIND_CHECK_VALUE_IS_DEFINED(rem);
+		(void) VALGRIND_CHECK_VALUE_IS_DEFINED(rem);
 		fprintf(stderr, "PASSED\n"); /* assuming CHECK_VALUE_IS_DEFINED doesn't print anything */
 	}
 

memcheck/tests/recursive-merge.c

@@ -55,16 +55,16 @@ int main(int argc, char**argv)
 
    doit(argc, argv); // with default value of our argument.
 
-   VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 3");
+   (void) VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 3");
    doit(argc, argv);
 
-   VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 2");
+   (void) VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 2");
    doit(argc, argv);
 
-   VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 1");
+   (void) VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 1");
    doit(argc, argv);
 
-   VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 0");
+   (void) VALGRIND_MONITOR_COMMAND("v.set merge-recursive-frames 0");
    doit(argc, argv);
 
    return 0;

memcheck/tests/sh-mem-random.c

@@ -40,7 +40,7 @@ U8 build(int size, U1 byte)
    U8 mask = 0;
    U8 shres;
    U8 res = 0xffffffffffffffffULL, res2;
-   VALGRIND_MAKE_MEM_UNDEFINED(&res, 8);
+   (void)VALGRIND_MAKE_MEM_UNDEFINED(&res, 8);
    assert(1 == size || 2 == size || 4 == size || 8 == size);
 
    for (i = 0; i < size; i++) {
@@ -63,7 +63,7 @@ U8 build(int size, U1 byte)
 U1 make_defined ( U1 x )
 {
    volatile U1 xx = x;
-   VALGRIND_MAKE_MEM_DEFINED(&xx, 1);
+   (void)VALGRIND_MAKE_MEM_DEFINED(&xx, 1);
    return xx;
 }
 

memcheck/tests/sh-mem.c

@@ -41,7 +41,7 @@ U8 build(int size, U1 byte)
    U8 mask = 0;
    U8 shres;
    U8 res = 0xffffffffffffffffULL, res2;
-   VALGRIND_MAKE_MEM_UNDEFINED(&res, 8);
+   (void)VALGRIND_MAKE_MEM_UNDEFINED(&res, 8);
    assert(1 == size || 2 == size || 4 == size || 8 == size);
 
    for (i = 0; i < size; i++) {
@@ -116,7 +116,7 @@ int main(void)
    //
    // which is useful for testing below.
    undefA = calloc(1, 256);         // one for each possible undefinedness value
-   VALGRIND_MAKE_MEM_UNDEFINED(undefA, 256);
+   (void)VALGRIND_MAKE_MEM_UNDEFINED(undefA, 256);
    for (i = 0; i < 256; i++) {
       undefA[i] &= i; 
    }
@@ -157,8 +157,8 @@ int main(void)
            /* the output of build() into a variable of type 'Ty'. */ \
             U8  tmpDef     = tmp; \
             ITy undefN_ITyDef = undefN_ITy; \
-            VALGRIND_MAKE_MEM_DEFINED(&tmpDef,        8  ); \
-            VALGRIND_MAKE_MEM_DEFINED(&undefN_ITyDef, NNN); \
+            (void)VALGRIND_MAKE_MEM_DEFINED(&tmpDef,        8  );       \
+            (void)VALGRIND_MAKE_MEM_DEFINED(&undefN_ITyDef, NNN);       \
             assert(tmpDef == (U8)undefN_ITyDef); \
          } \
          \

memcheck/tests/undef_malloc_args.c

@@ -11,29 +11,29 @@ int main (int argc, char*argv[])
 
    {
       size_t size = def_size;
-      VALGRIND_MAKE_MEM_UNDEFINED(&size, 1);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(&size, 1);
       p = malloc(size);
    }
 
-   VALGRIND_MAKE_MEM_UNDEFINED(&p, 1);
+   (void) VALGRIND_MAKE_MEM_UNDEFINED(&p, 1);
    new_p = realloc(p, def_size);
 
-   VALGRIND_MAKE_MEM_UNDEFINED(&new_p, 1);
+   (void) VALGRIND_MAKE_MEM_UNDEFINED(&new_p, 1);
    new_p = realloc(new_p, def_size);
 
-   VALGRIND_MAKE_MEM_UNDEFINED(&new_p, 1);
+   (void) VALGRIND_MAKE_MEM_UNDEFINED(&new_p, 1);
    free (new_p);
 
    {
       size_t nmemb = 1;
-      VALGRIND_MAKE_MEM_UNDEFINED(&nmemb, 1);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(&nmemb, 1);
       new_p = calloc(nmemb, def_size);
       free (new_p);
    }
 #if 0
    {
       size_t alignment = 1;
-      VALGRIND_MAKE_MEM_UNDEFINED(&alignment, 1);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(&alignment, 1);
       new_p = memalign(alignment, def_size);
       free(new_p);
    }
@@ -41,14 +41,14 @@ int main (int argc, char*argv[])
    {
       size_t nmemb = 16;
       size_t size = def_size;
-      VALGRIND_MAKE_MEM_UNDEFINED(&size, 1);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(&size, 1);
       new_p = memalign(nmemb, size);
       free(new_p);
    }
 
    {
       size_t size = def_size;
-      VALGRIND_MAKE_MEM_UNDEFINED(&size, 1);
+      (void) VALGRIND_MAKE_MEM_UNDEFINED(&size, 1);
       new_p = valloc(size);
       free (new_p);
    }

memcheck/tests/varinfo1.c

@@ -25,7 +25,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }

memcheck/tests/varinfo2.c

@@ -25,7 +25,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }

memcheck/tests/varinfo3.c

@@ -25,7 +25,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }

memcheck/tests/varinfo4.c

@@ -25,7 +25,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }

memcheck/tests/varinfo5so.c

@@ -26,7 +26,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }

memcheck/tests/varinfo6.c

@@ -31,7 +31,7 @@ void croak ( void* aV )
   char saved = *a;
   assert(undefp);
   *a = *undefp;
-  VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
+  (void) VALGRIND_CHECK_MEM_IS_DEFINED(a, 1);
   *a = saved;
   free(undefp);
 }