First version of malloc tester.

Currently unused, needs more fixing to be usable.

regress/Makefile.am

diff --git a/regress/Makefile.am b/regress/Makefile.am
index 42c73d2..fdccb90 100644
--- a/regress/Makefile.am
+++ b/regress/Makefile.am
@@ -18,6 +18,13 @@
 	hole.c \
 	source_hole.c
 
+pkglib_LTLIBRARIES=	malloc.la
+malloc_la_SOURCES=	malloc.c
+malloc_la_LDFLAGS=	-module -avoid-version
+
+install-pkglibLTLIBRARIES:
+	@echo not installing shared objects needed only for testing
+
 EXTRA_DIST= \
 	CMakeLists.txt \
 	NiHTest.pm \

regress/malloc.c

diff --git a/regress/malloc.c b/regress/malloc.c
new file mode 100644
index 0000000..2bdd34b
--- /dev/null
+++ b/regress/malloc.c
@@ -0,0 +1,144 @@
+/*
+  malloc.c -- override *alloc() to allow testing special cases
+  Copyright (C) 2015 Dieter Baron and Thomas Klausner
+
+  This file is part of ckmame, a program to check rom sets for MAME.
+  The authors can be contacted at <ckmame@nih.at>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+  3. The name of the author may not be used to endorse or promote
+     products derived from this software without specific prior
+     written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+  IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+  IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+//#include <string.h>
+#include <errno.h>
+#define __USE_GNU
+#include <dlfcn.h>
+#undef __USE_GNU
+
+static int inited = 0;
+static size_t count = 0;
+static size_t max_count = 0;
+static size_t min_size = 0;
+static void *(*real_malloc)(size_t size) = NULL;
+static void *(*real_calloc)(size_t number, size_t size) = NULL;
+static void *(*real_realloc)(void *ptr, size_t size) = NULL;
+
+static FILE *log;
+static const char *myname = NULL;
+
+// TODO: add sentinel -- check if particular size is malloced before doing other stuff
+// TODO: catch free for sentinel too
+// TODO: optionally, catch malloc of particular size
+
+static void
+init(void)
+{
+    char *foo;
+    myname = getprogname();
+    if (!myname)
+	myname = "(unknown)";
+    if ((foo=getenv("MALLOC_MAX_COUNT")) != NULL)
+	max_count = strtoul(foo, NULL, 0);
+    if ((foo=getenv("MALLOC_MIN_SIZE")) != NULL)
+	min_size = strtoul(foo, NULL, 0);
+    real_calloc = dlsym(RTLD_NEXT, "calloc");
+    if (!real_calloc)
+	abort();
+    real_malloc = dlsym(RTLD_NEXT, "malloc");
+    if (!real_malloc)
+	abort();
+    real_realloc = dlsym(RTLD_NEXT, "realloc");
+    if (!real_realloc)
+	abort();
+    inited = 1;
+}
+
+void *
+calloc(size_t number, size_t size)
+{
+    void *ret;
+
+    if (!inited) {
+	init();
+    }
+
+    if (number >= min_size/size && count >= max_count) {
+	errno = ENOMEM;
+	return NULL;
+    }
+
+    ret = real_calloc(number, size);
+    if (size >= min_size) {
+        count++;
+    }
+
+    return ret;
+}
+
+void *
+malloc(size_t size)
+{
+    void *ret;
+
+    if (!inited) {
+	init();
+    }
+
+    if (size >= min_size && count >= max_count) {
+	errno = ENOMEM;
+	return NULL;
+    }
+
+    ret = real_malloc(size);
+    if (size >= min_size) {
+        count++;
+    }
+
+    return ret;
+}
+
+void *
+realloc(void *ptr, size_t size)
+{
+    void *ret;
+
+    if (!inited) {
+	init();
+    }
+
+    if (size >= min_size && count >= max_count) {
+	errno = ENOMEM;
+	return NULL;
+    }
+
+    ret = real_realloc(ptr, size);
+    if (size >= min_size) {
+        count++;
+    }
+
+    return ret;
+}