use .so with LD_PRELOAD to greatly simplify usage

Author: chatziko

.gitignore

@@ -1,4 +1,5 @@
 *.o
 *.d
+*.so
 examples/examples
 .gdb_history

.vscode/launch.json

@@ -8,7 +8,9 @@
 			"program": "${workspaceFolder}/examples/examples",
 			"stopAtEntry": true,
 			"cwd": "${workspaceFolder}/examples",
-			"environment": [],
+			"environment": [
+				{"name":"LD_PRELOAD", "value":"../visualize-c-memory/visualize-c-memory.so"},
+			],
 			"externalConsole": false,
 			"linux": {
 				"MIMode": "gdb",

examples/Makefile

@@ -2,14 +2,15 @@
 CC = gcc
 CFLAGS = -Wall -g 
 
-# This allows to wrap malloc/free/... (see malloc-wrapper.c) so that we can track heap allocations
-LDFLAGS = -Wl,--wrap=malloc -Wl,--wrap=free
-
-OBJS = examples.o ../visualize-c-memory/malloc-wrapper.o
+LIB = ../visualize-c-memory
+OBJS = examples.o
 EXEC = examples
 
-$(EXEC): $(OBJS)
+$(EXEC): $(OBJS) $(LIB)/visualize-c-memory.so
 	$(CC) $(OBJS) -o $(EXEC) $(LDFLAGS)
 
+$(LIB)/visualize-c-memory.so:
+	$(MAKE) -C $(LIB) visualize-c-memory.so
+
 clean:
 	rm -f $(OBJS) $(EXEC)

visualize-c-memory/Makefile

@@ -0,0 +1,13 @@
+# options
+CC = gcc
+CFLAGS = -Wall -g -fpic
+LDFLAGS = -shared
+
+OBJS = visualize-c-memory.o
+LIB = visualize-c-memory.so
+
+$(LIB): $(OBJS)
+	$(CC) $(OBJS) -o $(LIB) $(LDFLAGS)
+
+clean:
+	rm -f $(OBJS) $(LIB)

visualize-c-memory/malloc-wrapper.c visualize-c-memory/visualize-c-memory.c

@@ -1,17 +1,15 @@
 #include <string.h>
 
-// malloc/free wrapper
-// It simply calls the real malloc/free while recording all
-// currenly allocated memory in the heap_contents linked list.
+// This file should be either linked with a C program directly, or
+// compiled into a shared library and loaded via LD_PRELOAD.
+//
+// It overrides malloc/realloc/free, calling the real ones while recording
+// all currenly allocated memory in the heap_contents linked list.
 
-void* __real_malloc(size_t);
-void __real_free(void*);
-
-// use weak symbols, to make wrapping of the following functions optional
-void* __attribute__((weak)) __real_calloc(size_t, size_t);
-void* __attribute__((weak)) __real_realloc(void*, size_t);
-char* __attribute__((weak)) __real_strdup(const char*);
-char* __attribute__((weak)) __real_strndup(const char*, size_t);
+extern void* __libc_malloc(size_t);
+extern void* __libc_realloc(void*, size_t);
+extern void* __libc_calloc(size_t, size_t);
+extern void* __libc_free(void*);
 
 
 // list management //////////////////////////////////////////////////////////////
@@ -36,7 +34,7 @@ static void insert_or_update_pointer(void* pointer, int size, void* old_pointer)
 		}
 	}
 
-	heap_node* node = __real_malloc(sizeof(*node));
+	heap_node* node = __libc_malloc(sizeof(*node));
 	node->pointer = pointer;
 	node->size = size;
 	node->next = NULL;
@@ -49,7 +47,7 @@ static void remove_pointer(void* pointer) {
 		heap_node* node = prev->next;
 		if(node != NULL && node->pointer == pointer) {
 			prev->next = node->next;
-			__real_free(node);
+			__libc_free(node);
 			break;
 		}
 	}
@@ -58,39 +56,29 @@ static void remove_pointer(void* pointer) {
 
 // wrappers ////////////////
 
-void* __wrap_malloc(size_t size) {
-	void* pointer = __real_malloc(size);
-	insert_or_update_pointer(pointer, size, NULL);
-	return pointer;
-}
+void* malloc(size_t size) {
+	void* pointer = __libc_malloc(size);
+
+	// libc seems to allocte 1024 bytes on start for its own use. Ignore it.
+	if(!(heap_contents.next == NULL && size == 1024))
+		insert_or_update_pointer(pointer, size, NULL);
 
-void* __wrap_calloc(size_t n, size_t size) {
-	void* pointer = __real_calloc(n, size);
-	insert_or_update_pointer(pointer, n * size, NULL);
 	return pointer;
 }
 
-void* __wrap_realloc(void* old_pointer, size_t size) {
-	void* pointer = __real_realloc(old_pointer, size);
+void* realloc(void* old_pointer, size_t size) {
+	void* pointer = __libc_realloc(old_pointer, size);
 	insert_or_update_pointer(pointer, size, old_pointer);
 	return pointer;
 }
 
-void __wrap_free(void* pointer) {
-	remove_pointer(pointer);
-	__real_free(pointer);
-}
-
-char* __wrap_strdup(const char* s) {
-	char* new_s = __real_strdup(s);
-	insert_or_update_pointer(new_s, strlen(new_s) + 1, NULL);
-	return new_s;
+void* calloc(size_t n, size_t size) {
+	void* pointer = __libc_calloc(n, size);
+	insert_or_update_pointer(pointer, n * size, NULL);
+	return pointer;
 }
 
-char* __wrap_strndup(const char* s, size_t n) {
-	char* new_s = __real_strndup(s, n);
-	insert_or_update_pointer(new_s, strlen(new_s) + 1, NULL);
-	return new_s;
+void free(void* pointer) {
+	remove_pointer(pointer);
+	__libc_free(pointer);
 }
-
-

visualize-c-memory/visualize-c-memory.py

@@ -36,7 +36,7 @@ def visualize_memory():
         # display errors using the text visualizer
         return json.dumps({
             'kind': { 'text': True },
-            'text': str(e) + "\n\n" + traceback.format_exc()
+            'text': str(e) + "\n\n\n\n\n\n\n" + traceback.format_exc()
         })
 
 def svg_of_memory():
@@ -240,8 +240,9 @@ def rec_of_heap():
     except:
         raise Exception(
             "Heap information not found.\n"
-            "You need to link your program with malloc-wrapper.c\n"
-            "and pass -Wl,--wrap=malloc -Wl,--wrap=free to the linker.\n"
+            "You need to load visualize-c-memory.so by setting the environment variable\n"
+            "     LD_PRELOAD=<path-to>/visualize-c-memory.so\n"
+            "_or_ link your program with visualize-c-memory.c"
         )
 
     while int(heap_node_ptr) != 0: