Silence clang warnings about uninitialised and unused values in

memcheck testcases.

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

diff --git a/memcheck/mc_replace_strmem.c b/memcheck/mc_replace_strmem.c
index 7474249fe79ad6adcdb58f1b45cc2a5648ec56f6..ec837887cd3b9b363a96aaf8eb845766812e5507 100644 (file)
--- a/memcheck/mc_replace_strmem.c
+++ b/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;
 }

diff --git a/memcheck/tests/Makefile.am b/memcheck/tests/Makefile.am
index 73b23fa9c1cf765c4cc052326e248a1e3a40d6b2..555f2ac96c3543e771eb6601a6af47a065844ae8 100644 (file)
--- a/memcheck/tests/Makefile.am
+++ b/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

diff --git a/memcheck/tests/addressable.c b/memcheck/tests/addressable.c
index bb6da4fce2d7632f3ea07eedd8c087b534314651..5f3c2e182ef0e47b4e821d884f16141005d85b9a 100644 (file)
--- a/memcheck/tests/addressable.c
+++ b/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 {

diff --git a/memcheck/tests/clientperm.c b/memcheck/tests/clientperm.c
index 5edf4a82a81acddec347303798abf972448df14b..ac7574788d2480ea784d03963b21c9cccb7d7d92 100644 (file)
--- a/memcheck/tests/clientperm.c
+++ b/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 );
 

diff --git a/memcheck/tests/common/sh-mem-vec128.tmpl.c b/memcheck/tests/common/sh-mem-vec128.tmpl.c
index 16ad43793684ce98d923abc8135e5da471696d7b..58a6f62f6ea261e49210adb8c07a0d4b9be2736b 100644 (file)
--- a/memcheck/tests/common/sh-mem-vec128.tmpl.c
+++ b/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 )

diff --git a/memcheck/tests/cond_ld_st.c b/memcheck/tests/cond_ld_st.c
index d9cced003e642debf8c65f74a315877c5338423b..8f7b01a37bb9e797b6cfc977f42e41316b2ed21f 100644 (file)
--- a/memcheck/tests/cond_ld_st.c
+++ b/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|.

diff --git a/memcheck/tests/custom_alloc.c b/memcheck/tests/custom_alloc.c
index 56cf94b2746e3840f48b3a7343c619321004a8a4..4e6d28bd62f7e3456ca4c2baca8715ea0a940ee6 100644 (file)
--- a/memcheck/tests/custom_alloc.c
+++ b/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]

diff --git a/memcheck/tests/describe-block.c b/memcheck/tests/describe-block.c
index 1cbd3b16c582439fd44acbbf68f300e61201d326..c4080b4c3fec7dd24908ce41643d5867af4766cd 100644 (file)
--- a/memcheck/tests/describe-block.c
+++ b/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;
 }

diff --git a/memcheck/tests/dw4.c b/memcheck/tests/dw4.c
index 8aac54d7d35ed874d7799df851148c327a7cccdc..c66c3784380a7c67b42926f49f7fb135e66bf9d8 100644 (file)
--- a/memcheck/tests/dw4.c
+++ b/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);
 }

diff --git a/memcheck/tests/holey_buffer_too_small.c b/memcheck/tests/holey_buffer_too_small.c
index ab420e999cc2f84815952151f5bd184f837a15c4..0cc4d028a7a4fe8f8825eba47ff8107535f8cadb 100644 (file)
--- a/memcheck/tests/holey_buffer_too_small.c
+++ b/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;

diff --git a/memcheck/tests/leak-pool.c b/memcheck/tests/leak-pool.c
index daa5381af15bf18fc8f9cc815b07a267b2ad507c..4ba0163e63dc31759da375e2e66ac95717edddaa 100644 (file)
--- a/memcheck/tests/leak-pool.c
+++ b/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;
 }
 

diff --git a/memcheck/tests/leak-segv-jmp.c b/memcheck/tests/leak-segv-jmp.c
index 7c965903a553a982fbc5ac3452334549ad9d93d6..76c04941e7b28b38c34bc2d52428378c4209ebe3 100644 (file)
--- a/memcheck/tests/leak-segv-jmp.c
+++ b/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);

diff --git a/memcheck/tests/leak_cpp_interior.cpp b/memcheck/tests/leak_cpp_interior.cpp
index ac1850a237bea59081d661ae0b3d588b7db77ef5..e2b52aae166d4823eb48054de00caf3626e84c1e 100644 (file)
--- a/memcheck/tests/leak_cpp_interior.cpp
+++ b/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;

diff --git a/memcheck/tests/malloc_free_fill.c b/memcheck/tests/malloc_free_fill.c
index 5dce9e0595989f2da26654c0bac88ace93b7cfa4..35a4ae3ce3553a321ef415f21f878adf08d6a295 100644 (file)
--- a/memcheck/tests/malloc_free_fill.c
+++ b/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 { \

diff --git a/memcheck/tests/match-overrun.c b/memcheck/tests/match-overrun.c
index b859ab3a353aaec9f8b70255af4108ecffebdb98..f07e5d74db434e4bd309b17acb08ad7ca1619994 100644 (file)
--- a/memcheck/tests/match-overrun.c
+++ b/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;
 }
 

diff --git a/memcheck/tests/mempool.c b/memcheck/tests/mempool.c
index 583441cb1c23fccaa029e47eef960ecd8124b718..2bd53183d9a717153fa0be81315b8c25f3d57fcd 100644 (file)
--- a/memcheck/tests/mempool.c
+++ b/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));

diff --git a/memcheck/tests/mempool2.c b/memcheck/tests/mempool2.c
index 256ff056d6a2529d6292bc19e61a7e3d9322ad42..8fa3d5c1fd9d46457970676b2c5ad12b9a443aaf 100644 (file)
--- a/memcheck/tests/mempool2.c
+++ b/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));

diff --git a/memcheck/tests/origin1-yes.c b/memcheck/tests/origin1-yes.c
index 79e351eca3ecd991bf53d0e73d092fa35a4317cd..a78313bace4fb33154c10236c4f6dd11e5807af5 100644 (file)
--- a/memcheck/tests/origin1-yes.c
+++ b/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);
    }

diff --git a/memcheck/tests/origin3-no.c b/memcheck/tests/origin3-no.c
index bec5e3e1b13889d9a883754e08e26058bc087175..a8145fa8444d484864936e5a6ee2f947ae17861d 100644 (file)
--- a/memcheck/tests/origin3-no.c
+++ b/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");

diff --git a/memcheck/tests/origin5-bz2.c b/memcheck/tests/origin5-bz2.c
index 45006ebcc82c500b7a351479cdc305e274a54efb..26fe161753eb7d8772b881a341b6b44522ad945d 100644 (file)
--- a/memcheck/tests/origin5-bz2.c
+++ b/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");
 

diff --git a/memcheck/tests/origin6-fp.c b/memcheck/tests/origin6-fp.c
index 79b8cc83d9394be6658a84ca056b442b02a3c97f..4ffdbb43266de8c2d1fe9ea0c73a31d6c4781321 100644 (file)
--- a/memcheck/tests/origin6-fp.c
+++ b/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);
       }
     }
   }

diff --git a/memcheck/tests/pointer-trace.c b/memcheck/tests/pointer-trace.c
index 243ea1ffb5f33193dd30842c5e0c8ac4076a7ad5..8bf82f46db005f49a5c47b76d64821c1260efaf5 100644 (file)
--- a/memcheck/tests/pointer-trace.c
+++ b/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;

diff --git a/memcheck/tests/post-syscall.c b/memcheck/tests/post-syscall.c
index 6fb2bfc6cab8fccfcd041c4496bc91562ac7aba1..cc473503e40f7a06ef71131f979afcaf9c76d0f2 100644 (file)
--- a/memcheck/tests/post-syscall.c
+++ b/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 */
        }
 

diff --git a/memcheck/tests/recursive-merge.c b/memcheck/tests/recursive-merge.c
index 61caac727724e9bde247494fcfa5c9c2287a8f83..204f00eba621df17a0d99d8f40862d347752df80 100644 (file)
--- a/memcheck/tests/recursive-merge.c
+++ b/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;

diff --git a/memcheck/tests/sh-mem-random.c b/memcheck/tests/sh-mem-random.c
index 5564858394c670d2c1a96c095f77d87eb136a2d1..5e4361c39d7f704c186d8fc84f30e1061732aec6 100644 (file)
--- a/memcheck/tests/sh-mem-random.c
+++ b/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;
 }
 

diff --git a/memcheck/tests/sh-mem.c b/memcheck/tests/sh-mem.c
index 7e50528e68e04847e66baca817d5459858144498..58ae63c66234c7e887bf8c9aca8e3cc13bb7181d 100644 (file)
--- a/memcheck/tests/sh-mem.c
+++ b/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); \
          } \
          \

diff --git a/memcheck/tests/undef_malloc_args.c b/memcheck/tests/undef_malloc_args.c
index dc942b35a3a67e34baeee88524fc0ebafd3c3fca..99e27999c26d69aa5bf37bb5c1238e4b84a366e1 100644 (file)
--- a/memcheck/tests/undef_malloc_args.c
+++ b/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);
    }

diff --git a/memcheck/tests/varinfo1.c b/memcheck/tests/varinfo1.c
index 752d698fa33e348428435da8dc7aaa3657cda573..6a739566fe2bd935c6605f07018827d83a89d3f3 100644 (file)
--- a/memcheck/tests/varinfo1.c
+++ b/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);
 }

diff --git a/memcheck/tests/varinfo2.c b/memcheck/tests/varinfo2.c
index 7ccea80c1e19103a084094df8a5eff709d529d95..97079c255d427f6c0b5b9d998606ea7f6724e7f9 100644 (file)
--- a/memcheck/tests/varinfo2.c
+++ b/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);
 }

diff --git a/memcheck/tests/varinfo3.c b/memcheck/tests/varinfo3.c
index 2523d91b610cb3d769e61dd7a62568209f53d4da..08a1483b6eec68768fb498df456635f2ee9a9ffc 100644 (file)
--- a/memcheck/tests/varinfo3.c
+++ b/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);
 }

diff --git a/memcheck/tests/varinfo4.c b/memcheck/tests/varinfo4.c
index 499e08731d989139670d524efb8394292a4c74be..71643cdea92f548a2fe07e23507a53a244016922 100644 (file)
--- a/memcheck/tests/varinfo4.c
+++ b/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);
 }

diff --git a/memcheck/tests/varinfo5so.c b/memcheck/tests/varinfo5so.c
index fab8174c01c9e443c6a656a77dacaf85384393a1..d90fbc4e914f62933b850de607f7aafee7011a2b 100644 (file)
--- a/memcheck/tests/varinfo5so.c
+++ b/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);
 }

diff --git a/memcheck/tests/varinfo6.c b/memcheck/tests/varinfo6.c
index 2fff8964a1645fe80c3c6c93edaad71d5c5968e5..7d835e0f893277d4fb9770f0e48f725307903922 100644 (file)
--- a/memcheck/tests/varinfo6.c
+++ b/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);
 }