*** a/Makefile.am	2014-05-29 10:40:14.997714171 -0600

--- b/Makefile.am	2014-05-29 12:42:18.358166208 -0600

*************** libmemstomp_la_LIBADD = \

*** 53,58 ****

--- 53,60 ----

  	-ldl

  libmemstomp_la_CFLAGS = \

  	$(PTHREAD_CFLAGS) \

+ 	-fno-tree-vrp \

+ 	-fno-delete-null-pointer-checks \

  	-DSONAME=\"libmemstomp.so\"

  libmemstomp_backtrace_symbols_la_SOURCES = \

*************** libmemstomp_backtrace_symbols_la_LIBADD

*** 68,74 ****

  	-lrt \

  	-ldl

  libmemstomp_backtrace_symbols_la_CFLAGS = \

! 	$(PTHREAD_CFLAGS)

  memstomp: memstomp.in Makefile

  	sed -e 's,@PACKAGE_STRING\@,$(PACKAGE_STRING),g' \

--- 70,76 ----

  	-lrt \

  	-ldl

  libmemstomp_backtrace_symbols_la_CFLAGS = \

! 	$(PTHREAD_CFLAGS) 

  memstomp: memstomp.in Makefile

  	sed -e 's,@PACKAGE_STRING\@,$(PACKAGE_STRING),g' \

*** a/memstomp.c	2014-05-29 10:40:15.016714123 -0600

--- b/memstomp.c	2014-05-29 13:59:20.314343481 -0600

***************

*** 62,67 ****

--- 62,79 ----

  #define likely(x)	__builtin_expect(!!(x), 1)

  #define unlikely(x)	__builtin_expect(!!(x), 0)

+ #undef strcmp

+ #undef strncmp

+ #undef strdup

+ #undef strndup

+ #undef strchr

+ #undef strrchr

+ #undef strcspn

+ #undef strspn

+ #undef strpbrk

+ #undef strtok_r

+ #undef memcmp

+ 

  static bool abrt_trap = false;

  static bool quiet_mode = false;

*************** static void warn_copylap(void * dest, co

*** 316,321 ****

--- 328,356 ----

  	free(info);

  }

+ static void warn_null(char const *name)

+ {

+ 	char prname[17];

+ 	char buf[160];

+ 

+ /* Avoid fprintf which is not async signal safe.  fprintf may call malloc,

+  * which may experience trouble if the bad memcpy was called from a signal

+  * handler whose invoking signal interrupted malloc.

+  */

+ 	int const j = snprintf(buf, sizeof(buf),

+ 		"\n\n%s NULL pointer %s(%d)\n",

+ 		name, get_prname(prname), getpid());

+ 	write(STDERR_FILENO, buf, umin(j, sizeof(buf)));

+ 	

+ /* If generate_stacktrace() indirectly invokes malloc (such as via libbfd),

+  * then this is not async signal safe.  But the write() above will produce

+  * some evidence before any possible trouble below.

+  */

+ 	char *const info = generate_stacktrace();

+ 	fprintf(stderr, "%s", info);

+ 	free(info);

+ }

+ 

  static void *copy(void *dest, void const *src, size_t count, char const *name)

  {

  	size_t d = (char *)dest - (char *)src;

*************** static void *copy(void *dest, void const

*** 326,331 ****

--- 361,367 ----

  		/* report the overlap */

  		warn_copylap(dest, src, count, name);

  	}

+ 

  	/* be safe use memmove */

  	return memmove(dest, src, count);

  }

*************** char *stpncpy(char *dst, char const *src

*** 496,498 ****

--- 532,956 ----

  /* XXX wcstok: Ugly! */

+ /* All the interposition routines below are just checking for NULL

+    arguments when ISO demands they be non-null.  */

+ 

+ void *memmove (void *dest, const void *src, size_t n)

+ {

+   static void * (*real_memmove)(void *, const void *, size_t) = NULL;

+   if (!real_memmove)

+ 	real_memmove = dlsym(RTLD_NEXT, "memmove");

+ 

+   if (unlikely (dest == NULL || src == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("memmove");

+ 	return 0;

+   }

+ 

+   return real_memmove (dest, src, n);

+ }

+ 

+ int memcmp (const void *__s1, const void *__s2, size_t __n)

+ {

+   static int (*real_memcmp)(const void *, const void *, size_t) = NULL;

+   if (!real_memcmp)

+ 	real_memcmp = dlsym(RTLD_NEXT, "memcmp");

+ 

+   if (unlikely (__s1 == NULL || __s2 == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("memcmp");

+ 	return 0;

+   }

+ 

+   return real_memcmp (__s1, __s2, __n);

+ }

+ 

+ int strcmp (const char *__s1, const char *__s2)

+ {

+   static int (*real_strcmp)(const char *, const char *) = NULL;

+   if (!real_strcmp)

+ 	real_strcmp = dlsym(RTLD_NEXT, "strcmp");

+ 

+   if (unlikely (__s1 == NULL || __s2 == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strcmp");

+ 	return 0;

+   }

+ 

+   return real_strcmp (__s1, __s2);

+ }

+ 

+ int strncmp (const char *__s1, const char *__s2, size_t __n)

+ {

+   static int (*real_strncmp)(const char *, const char *, size_t) = NULL;

+   if (!real_strncmp)

+ 	real_strncmp = dlsym(RTLD_NEXT, "strncmp");

+ 

+   if (unlikely (__s1 == NULL || __s2 == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strncmp");

+ 	return 0;

+   }

+ 

+   return real_strncmp (__s1, __s2, __n);

+ }

+ 

+ int strcoll (const char *__s1, const char *__s2)

+ {

+   static int (*real_strcoll)(const char *, const char *) = NULL;

+   if (!real_strcoll)

+ 	real_strcoll = dlsym(RTLD_NEXT, "strcoll");

+ 

+   if (unlikely (__s1 == NULL || __s2 == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strcoll");

+ 	return 0;

+   }

+ 

+   return real_strcoll (__s1, __s2);

+ }

+ 

+ int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)

+ {

+   static int (*real_strcoll_l)(const char *, const char *, __locale_t) = NULL;

+   if (!real_strcoll_l)

+ 	real_strcoll_l = dlsym(RTLD_NEXT, "strcoll_l");

+ 

+   if (unlikely (__s1 == NULL || __s2 == NULL || __l == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strcoll_l");

+ 	return 0;

+   }

+ 

+   return real_strcoll_l (__s1, __s2, __l);

+ }

+ 

+ size_t strxfrm (char *__dest, const char *__src, size_t __n)

+ {

+   static size_t (*real_strxfrm)(char *, const char *, size_t) = NULL;

+   if (!real_strxfrm)

+ 	real_strxfrm = dlsym(RTLD_NEXT, "strxfrm");

+ 

+   if (unlikely (__src == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strxfrm");

+ 	return 0;

+   }

+ 

+   return real_strxfrm (__dest, __src, __n);

+ }

+ 

+ size_t strxfrm_l (char *__dest, const char *__src, size_t __n, __locale_t __l)

+ {

+   static size_t (*real_strxfrm_l)(char *, const char *, size_t, __locale_t) = NULL;

+   if (!real_strxfrm_l)

+ 	real_strxfrm_l = dlsym(RTLD_NEXT, "strxfrm_l");

+ 

+   if (unlikely (__src == NULL || __l == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strxfrm_l");

+ 	return 0;

+   }

+ 

+   return real_strxfrm_l (__dest, __src, __n, __l);

+ }

+ 

+ 

+ void *memset (void *__s, int __c, size_t __n)

+ {

+   static void * (*real_memset)(void *, int, size_t) = NULL;

+   if (!real_memset)

+ 	real_memset = dlsym(RTLD_NEXT, "memset");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("memset");

+ 	return 0;

+   }

+ 

+   return real_memset (__s, __c, __n);

+ }

+ 

+ void *memchr (const void *__s, int __c, size_t __n)

+ {

+   static void * (*real_memchr)(const void *, int, size_t) = NULL;

+   if (!real_memchr)

+ 	real_memchr = dlsym(RTLD_NEXT, "memchr");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("memchr");

+ 	return 0;

+   }

+ 

+   return real_memchr (__s, __c, __n);

+ }

+ 

+ void *memrchr (const void *__s, int __c, size_t __n)

+ {

+   static void * (*real_memrchr)(const void *, int, size_t) = NULL;

+   if (!real_memrchr)

+ 	real_memrchr = dlsym(RTLD_NEXT, "memrchr");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("memrchr");

+ 	return 0;

+   }

+ 

+   return real_memrchr (__s, __c, __n);

+ }

+ 

+ void *rawmemchr (const void *__s, int __c)

+ {

+   static void * (*real_rawmemchr)(const void *, int, size_t) = NULL;

+   if (!real_rawmemchr)

+ 	real_rawmemchr = dlsym(RTLD_NEXT, "rawmemchr");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("rawmemchr");

+ 	return 0;

+   }

+ 

+   return real_rawmemchr (__s, __c, __c);

+ }

+ 

+ size_t strlen (const char *__s)

+ {

+   static size_t (*real_strlen)(const char *) = NULL;

+   if (!real_strlen)

+ 	real_strlen = dlsym(RTLD_NEXT, "strlen");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strlen");

+ 	return 0;

+   }

+ 

+   return real_strlen (__s);

+ }

+ 

+ char *strdup (const char *__s)

+ {

+   static char *(*real_strdup)(const char *) = NULL;

+   if (!real_strdup)

+ 	real_strdup = dlsym(RTLD_NEXT, "strdup");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strdup");

+ 	return 0;

+   }

+ 

+   return real_strdup (__s);

+ }

+ 

+ char *strndup (const char *__s, size_t __n)

+ {

+   static char *(*real_strndup)(const char *, size_t) = NULL;

+   if (!real_strndup)

+ 	real_strndup = dlsym(RTLD_NEXT, "strndup");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strndup");

+ 	return 0;

+   }

+ 

+   return real_strndup (__s, __n);

+ }

+ 

+ char *strchr (const char *__s, int __c)

+ {

+   static char * (*real_strchr)(const void *, int) = NULL;

+   if (!real_strchr)

+ 	real_strchr = dlsym(RTLD_NEXT, "strchr");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strchr");

+ 	return 0;

+   }

+ 

+   return real_strchr (__s, __c);

+ }

+ 

+ char *strrchr (const char *__s, int __c)

+ {

+   static char * (*real_strrchr)(const void *, int) = NULL;

+   if (!real_strrchr)

+ 	real_strrchr = dlsym(RTLD_NEXT, "strrchr");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strrchr");

+ 	return 0;

+   }

+ 

+   return real_strrchr (__s, __c);

+ }

+ 

+ char *strchrnul (const char *__s, int __c)

+ {

+   static char * (*real_strchrnul)(const void *, int) = NULL;

+   if (!real_strchrnul)

+ 	real_strchrnul = dlsym(RTLD_NEXT, "strchrnul");

+ 

+   if (unlikely (__s == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strchrnul");

+ 	return 0;

+   }

+ 

+   return real_strchrnul (__s, __c);

+ }

+ 

+ size_t strcspn (const char *__s, const char *__reject)

+ {

+   static size_t (*real_strcspn)(const void *, const char *) = NULL;

+   if (!real_strcspn)

+ 	real_strcspn = dlsym(RTLD_NEXT, "strcspn");

+ 

+   if (unlikely (__s == NULL || __reject == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strcspn");

+ 	return 0;

+   }

+ 

+   return real_strcspn (__s, __reject);

+ }

+ 

+ size_t strspn (const char *__s, const char *__accept)

+ {

+   static size_t (*real_strspn)(const void *, const char *) = NULL;

+   if (!real_strspn)

+ 	real_strspn = dlsym(RTLD_NEXT, "strspn");

+ 

+   if (unlikely (__s == NULL || __accept == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strspn");

+ 	return 0;

+   }

+ 

+   return real_strspn (__s, __accept);

+ }

+ 

+ char * strpbrk (const char *__s, const char *__accept)

+ {

+   static char * (*real_strpbrk)(const void *, const char *) = NULL;

+   if (!real_strpbrk)

+ 	real_strpbrk = dlsym(RTLD_NEXT, "strpbrk");

+ 

+   if (unlikely (__s == NULL || __accept == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strpbrk");

+ 	return 0;

+   }

+ 

+   return real_strpbrk (__s, __accept);

+ }

+ 

+ char * strstr (const char *__haystack, const char *__needle)

+ {

+   static char * (*real_strstr)(const void *, const char *) = NULL;

+   if (!real_strstr)

+ 	real_strstr = dlsym(RTLD_NEXT, "strstr");

+ 

+   if (unlikely (__haystack == NULL || __needle == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strstr");

+ 	return 0;

+   }

+ 

+   return real_strstr (__haystack, __needle);

+ }

+ 

+ char *strcasestr (const char *__haystack, const char *__needle)

+ {

+   static char * (*real_strcasestr)(const void *, const char *) = NULL;

+   if (!real_strcasestr)

+ 	real_strcasestr = dlsym(RTLD_NEXT, "strcasestr");

+ 

+   if (unlikely (__haystack == NULL || __needle == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strcasestr");

+ 	return 0;

+   }

+ 

+   return real_strcasestr (__haystack, __needle);

+ }

+ 

+ void *memmem (const void *__haystack, size_t __haystacklen,

+ 	      const void *__needle, size_t __needlelen)

+ {

+   static char * (*real_memmem)(const void *, size_t, const char *, size_t) = NULL;

+   if (!real_memmem)

+ 	real_memmem = dlsym(RTLD_NEXT, "memmem");

+ 

+   if (unlikely (__haystack == NULL || __needle == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("memmem");

+ 	return 0;

+   }

+ 

+   return real_memmem (__haystack, __haystacklen, __needle, __needlelen);

+ }

+ 

+ char * strtok (char *__s, const char *__delim)

+ {

+   static char * (*real_strtok)(void *, const char *) = NULL;

+   if (!real_strtok)

+ 	real_strtok = dlsym(RTLD_NEXT, "strtok");

+ 

+   if (unlikely (__delim == NULL)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strtok");

+ 	return 0;

+   }

+ 

+   return real_strtok (__s, __delim);

+ }

+ 

+ 

+ char * strtok_r (char *__s, const char *__delim, char **__save_ptr)

+ {

+   static char * (*real_strtok_r)(void *, const char *, char **) = NULL;

+   if (!real_strtok_r)

+ 	real_strtok_r = dlsym(RTLD_NEXT, "strtok_r");

+ 

+   if (unlikely (__delim == NULL || __save_ptr)) {

+ 	if (abrt_trap) ABRT_TRAP;

+ 	/* report the NULL pointer */

+ 	warn_null("strtok_r");

+ 	return 0;

+   }

+ 

+   return real_strtok_r (__s, __delim, __save_ptr);

+ }

+ 

diff -Nrup a/testsuite/memstomp.null/memccpy.c b/testsuite/memstomp.null/memccpy.c

--- a/testsuite/memstomp.null/memccpy.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memccpy.c	2014-05-29 12:42:18.358166208 -0600

@@ -0,0 +1,20 @@

+#define _GNU_SOURCE

+#include <string.h>

+#include <wchar.h>

+

+#ifndef MEMCCPY

+#define MEMCCPY memccpy

+#define TYPE char

+#endif

+

+TYPE arr1[10] = {0};

+TYPE arr2[10] = {0};

+TYPE *p1 = &arr1[0];

+TYPE *p2 = &arr2[1];

+size_t count = 9;

+main ()

+{

+  MEMCCPY (NULL, NULL, -1, 0);

+}

+

+

diff -Nrup a/testsuite/memstomp.null/memchr.c b/testsuite/memstomp.null/memchr.c

--- a/testsuite/memstomp.null/memchr.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memchr.c	2014-05-29 14:09:04.667841941 -0600

@@ -0,0 +1,4 @@

+#define MEMSET memchr

+#define TYPE char

+#include "memset.c"

+

diff -Nrup a/testsuite/memstomp.null/memcmp.c b/testsuite/memstomp.null/memcmp.c

--- a/testsuite/memstomp.null/memcmp.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memcmp.c	2014-05-29 13:57:53.098567650 -0600

@@ -0,0 +1,3 @@

+#define MEMCPY memcmp

+#define TYPE char

+#include "memcpy.c"

diff -Nrup a/testsuite/memstomp.null/memcpy.c b/testsuite/memstomp.null/memcpy.c

--- a/testsuite/memstomp.null/memcpy.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memcpy.c	2014-05-29 14:01:34.002999896 -0600

@@ -0,0 +1,20 @@

+#define _GNU_SOURCE

+#include <string.h>

+#include <wchar.h>

+

+#ifndef MEMCPY

+#define MEMCPY memcpy

+#define TYPE char

+#endif

+

+TYPE arr1[10] = {0};

+TYPE arr2[10] = {0};

+TYPE *p1 = &arr1[0];

+TYPE *p2 = &arr2[1];

+size_t count = 9;

+main ()

+{

+  return MEMCPY (NULL, NULL, 0) == 0 ;

+}

+

+

diff -Nrup a/testsuite/memstomp.null/memmem.c b/testsuite/memstomp.null/memmem.c

--- a/testsuite/memstomp.null/memmem.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memmem.c	2014-05-29 14:18:37.569363960 -0600

@@ -0,0 +1,20 @@

+#define _GNU_SOURCE

+#include <string.h>

+#include <wchar.h>

+

+#ifndef MEMMEM

+#define MEMMEM memmem

+#define TYPE char

+#endif

+

+TYPE arr1[10] = {0};

+TYPE arr2[10] = {0};

+TYPE *p1 = &arr1[0];

+TYPE *p2 = &arr2[1];

+size_t count = 9;

+main ()

+{

+  return MEMMEM (NULL, 0, NULL, 0) == 0 ;

+}

+

+

diff -Nrup a/testsuite/memstomp.null/memmove.c b/testsuite/memstomp.null/memmove.c

--- a/testsuite/memstomp.null/memmove.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memmove.c	2014-05-29 13:57:29.563628151 -0600

@@ -0,0 +1,3 @@

+#define MEMCPY memmove

+#define TYPE char

+#include "memcpy.c"

diff -Nrup a/testsuite/memstomp.null/mempcpy.c b/testsuite/memstomp.null/mempcpy.c

--- a/testsuite/memstomp.null/mempcpy.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/mempcpy.c	2014-05-29 12:42:18.358166208 -0600

@@ -0,0 +1,3 @@

+#define MEMCPY mempcpy

+#define TYPE char

+#include "memcpy.c"

diff -Nrup a/testsuite/memstomp.null/memrchr.c b/testsuite/memstomp.null/memrchr.c

--- a/testsuite/memstomp.null/memrchr.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memrchr.c	2014-05-29 14:09:22.122797099 -0600

@@ -0,0 +1,4 @@

+#define MEMSET memrchr

+#define TYPE char

+#include "memset.c"

+

diff -Nrup a/testsuite/memstomp.null/memset.c b/testsuite/memstomp.null/memset.c

--- a/testsuite/memstomp.null/memset.c	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/memset.c	2014-05-29 14:08:06.411991603 -0600

@@ -0,0 +1,20 @@

+#define _GNU_SOURCE

+#include <string.h>

+#include <wchar.h>

+

+#ifndef MEMSET

+#define MEMSET memset

+#define TYPE char

+#endif

+

+TYPE arr1[10] = {0};

+TYPE arr2[10] = {0};

+TYPE *p1 = &arr1[0];

+TYPE *p2 = &arr2[1];

+size_t count = 9;

+main ()

+{

+  return MEMSET (NULL, -1, 0) == 0;

+}

+

+

diff -Nrup a/testsuite/memstomp.null/null.exp b/testsuite/memstomp.null/null.exp

--- a/testsuite/memstomp.null/null.exp	1969-12-31 17:00:00.000000000 -0700

+++ b/testsuite/memstomp.null/null.exp	2014-05-29 12:42:18.358166208 -0600

@@ -0,0 +1,59 @@

+# Copyright (C) 2013 Free Software Foundation, Inc.

+

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 3 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with GCC; see the file COPYING3.  If not see

+# <http://www.gnu.org/licenses/>.

+#

+# This was originally copied from GCC's dejagnu testing framework

+#

+

+load_lib memstomp.exp

+set memstomp [find_memstomp]

+set libmemstomp [find_libmemstomp]

+

+if $tracelevel then {

+    strace $tracelevel

+}

+

+#

+# main test loop

+#

+

+proc compile-and-execute { sources } {

+  global memstomp

+  global libmemstomp

+

+  set src [lindex $sources 0]

+

+  if {[catch {exec gcc -fno-builtin $src} results]} {

+    fail "$src compilation $results"

+  } else {

+    pass "$src compilation $results"

+  }

+

+  catch {exec /bin/bash -c "LD_PRELOAD=$libmemstomp $memstomp ./a.out"} results

+  if {[regexp "NULL pointer" $results]} {

+    pass "$src found NULL $results"

+  } else {

+    fail "$src found NULL $results"

+  }

+}

+

+foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.c]] {

+    # If we're only testing specific files and this isn't one of them, skip it.

+    if ![runtest_file_p $runtests $src] then {

+        continue

+    }

+

+   compile-and-execute $src

+}

diff -Nrup a/testsuite/memstomp.null/rawmemchr.c b/testsuite/memstomp.null/rawmemchr.c