Add a regression test for memcheck's ability do deal with partially

defined operands in equality comparisons.



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

memcheck/tests/Makefile.am

@@ -59,6 +59,8 @@ EXTRA_DIST = $(noinst_SCRIPTS) \
 	new_override.stderr.exp new_override.stdout.exp new_override.vgtest \
 	null_socket.stderr.exp null_socket.vgtest \
 	overlap.stderr.exp overlap.stdout.exp overlap.vgtest \
+	partiallydefinedeq.vgtest partiallydefinedeq.stderr.exp \
+	partiallydefinedeq.stdout.exp \
 	pointer-trace.vgtest \
 	pointer-trace.stderr.exp pointer-trace.stderr.exp64 \
 	post-syscall.stderr.exp post-syscall.stdout.exp post-syscall.vgtest \
@@ -101,6 +103,7 @@ check_PROGRAMS = \
 	memalign_test memalign2 memcmptest mempool mmaptest \
 	nanoleak new_nothrow \
 	null_socket overlap \
+	partiallydefinedeq \
 	pointer-trace \
 	post-syscall \
 	realloc1 realloc2 realloc3 \

memcheck/tests/partiallydefinedeq.c

@@ -0,0 +1,55 @@
+
+#include <stdio.h>
+#include <malloc.h>
+
+// Do a test comparison.  By default memcheck does not use the
+// expensive EQ/NE scheme as it would be too expensive.  The 
+// assignment to *hack is a trick to fool memcheck's bogus-literal
+// spotter into thinking this is a bb which needs unusually careful
+// attention, and therefore the expensive EQ/NE scheme is used.
+
+__attribute__((noinline)) // keep your grubby hands off this fn
+void foo ( int* p1, int* p2, unsigned int * hack )
+{
+  *hack = 0x80808080;
+  if (*p1 == *p2)
+    printf("foo\n");
+  else
+    printf("bar\n");
+}
+
+
+int main ( void )
+{
+
+  unsigned int hack;
+
+  int* junk1 = malloc(sizeof(int));
+  int* junk2 = malloc(sizeof(int));
+
+  short* ps1 = (short*)junk1;
+  short* ps2 = (short*)junk2;
+
+  int*   pi1 = (int*)junk1;
+  int*   pi2 = (int*)junk2;
+
+  // both words completely undefined.  This should give an error.
+  foo(pi1,pi2, &hack);
+
+  // set half of the words, but to different values; so this should
+  // not give an error, since inspection of the defined parts 
+  // shows the two values are not equal, and so the definedness of
+  // the conclusion is unaffected by the undefined halves.
+  *ps1 = 41;
+  *ps2 = 42;
+  foo(pi1,pi2, &hack);
+
+  // set half of the words, but to the same value, so this forces the
+  // result of the comparison to depend on the undefined halves.
+  // should give an error
+  *ps1 = 42;
+  *ps2 = 42;
+  foo(pi1,pi2, &hack);
+
+  return 0;
+}

memcheck/tests/partiallydefinedeq.stderr.exp

@@ -0,0 +1,14 @@
+
+Conditional jump or move depends on uninitialised value(s)
+   at 0x........: foo (partiallydefinedeq.c:15)
+   by 0x........: main (partiallydefinedeq.c:37)
+
+Conditional jump or move depends on uninitialised value(s)
+   at 0x........: foo (partiallydefinedeq.c:15)
+   by 0x........: main (partiallydefinedeq.c:52)
+
+ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
+malloc/free: in use at exit: 8 bytes in 2 blocks.
+malloc/free: 2 allocs, 0 frees, 8 bytes allocated.
+For a detailed leak analysis,  rerun with: --leak-check=yes
+For counts of detected errors, rerun with: -v

memcheck/tests/partiallydefinedeq.stdout.exp

@@ -0,0 +1,3 @@
+foo
+bar
+foo

memcheck/tests/partiallydefinedeq.vgtest

@@ -0,0 +1 @@
+prog: partiallydefinedeq