Port to DynASM, passes (almost) all selftests

Changes main output to be generating machine code via DynASM, rather
than outputting text to be passed to the assembler.

Because chibicc assumes run-and-exit, it doesn't do any free/cleanup.
To work around this, while compiling multiple translation units in a
single run, each module jankily purges and resets and the heap is tossed
between files.

For each translation unit, a custom-obj-ish thing is output (which maybe
should have been ELF or whatever instead of custom...). After compiling
all the files listed on the command line, it does a link pass to handle
function references cross-module as well as data relocations (for
example to create literals or initialize global data). There's also no
particularly good reason that these objs (.dyo) need to be written to
disk (rather than simply being an in-memory structure), it was just
useful to debug the output.

All chibicc self-tests are passing except for two: 1) asm.c (because it
just passes the text of the asm block to the system assembler which no
longer exists); and 2) tls.c just because TLS support hasn't been
written yet.

This change also deletes most of the "driver" part of main.c as it
didn't seem to make a lot of sense with a JIT mode. Perhaps it would be
useful to bring some of that back, if only to be able to use it to build
common C software like sqlite, etc. for testing purposes.

The code for -S (output textual assembler) that is chibicc's normal mode
is still in the code, this was done during the rewrite to make it easier
to track. A future change will remove that code; a pristine copy of
chibicc is equally useful to compare final output with in any case.

Author: sgraham

Makefile

@@ -1,50 +1,81 @@
-CFLAGS=-std=c11 -g -fno-common -Wall -Wno-switch
+CFLAGS=-std=c11 -g -fno-common -Wall -Werror -Wno-switch -pthread
 
-SRCS=codegen.c hashmap.c main.c parse.c preprocess.c strings.c tokenize.c type.c unicode.c
+SRCS=codegen.c hashmap.c main.c parse.c preprocess.c strings.c tokenize.c type.c unicode.c alloc.c dyo.c link.c
 OBJS=$(SRCS:.c=.o)
 
-TEST_SRCS=$(wildcard test/*.c)
-TESTS=$(TEST_SRCS:.c=.exe)
-
-# Stage 1
+# XXX:
+# test/asm.c
+#   chibicc passes asm() blocks directly through to the system assembler, so now
+#   that we're not using that, there's no assembler available.
+#
+# test/tls.c
+#   TLS not implemented
+#
+# test/commonsym.c
+#   currently passes, but I thought I disabled support, so need to investigate.
+#
+TEST_SRCS=\
+test/alignof.c \
+test/alloca.c \
+test/arith.c \
+test/atomic.c \
+test/attribute.c \
+test/bitfield.c \
+test/builtin.c \
+test/cast.c \
+test/commonsym.c \
+test/compat.c \
+test/complit.c \
+test/const.c \
+test/constexpr.c \
+test/control.c \
+test/decl.c \
+test/enum.c \
+test/extern.c \
+test/float.c \
+test/function.c \
+test/generic.c \
+test/initializer.c \
+test/line.c \
+test/literal.c \
+test/macro.c \
+test/offsetof.c \
+test/pointer.c \
+test/pragma-once.c \
+test/sizeof.c \
+test/stdhdr.c \
+test/string.c \
+test/struct.c \
+test/typedef.c \
+test/typeof.c \
+test/usualconv.c \
+test/unicode.c \
+test/union.c \
+test/varargs.c \
+test/variable.c \
+test/vla.c
 
 chibicc: $(OBJS)
-	$(CC) $(CFLAGS) -o $@ $^ wait_hack.c $(LDFLAGS)
-
-$(OBJS): chibicc.h
-
-test/%.exe: chibicc test/%.c
-	./chibicc -Iinclude -Itest -c -o test/$*.o test/$*.c
-	$(CC) -pthread -o $@ test/$*.o wait_hack.c -xc test/common
+	$(CC) $(CFLAGS) -o $@ $^ wait_hack.c -ldl $(LDFLAGS)
 
-test: $(TESTS)
-	for i in $^; do echo $$i; ./$$i || exit 1; echo; done
-	test/driver.sh ./chibicc
+dumpdyo: dumpdyo.o dyo.o hashmap.o alloc.o
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
 
-test-all: test test-stage2
-
-# Stage 2
-
-stage2/chibicc: $(OBJS:%=stage2/%)
-	$(CC) $(CFLAGS) -o $@ wait_hack.c $^ $(LDFLAGS)
+$(OBJS): chibicc.h
 
-stage2/%.o: chibicc %.c
-	mkdir -p stage2/test
-	./chibicc -c -o $(@D)/$*.o $*.c
+minilua: dynasm/minilua.c
+	$(CC) $(CFLAGS) -o $@ $^ -lm
 
-stage2/test/%.exe: stage2/chibicc test/%.c
-	mkdir -p stage2/test
-	./stage2/chibicc -Iinclude -Itest -c -o stage2/test/$*.o test/$*.c
-	$(CC) -pthread -o $@ stage2/test/$*.o -xc test/common
+codegen.c: codegen.in.c minilua
+	./minilua dynasm/dynasm.lua -o $@ codegen.in.c
 
-test-stage2: $(TESTS:test/%=stage2/test/%)
-	for i in $^; do echo $$i; ./$$i || exit 1; echo; done
-	test/driver.sh ./stage2/chibicc
+test: $(TEST_SRCS) chibicc
+	for i in $(filter-out chibicc,$^); do echo $$i; ./chibicc -Itest test/common $$i || exit 1; echo; done
 
 # Misc.
 
 clean:
-	rm -rf chibicc tmp* $(TESTS) test/*.s test/*.exe stage2
+	rm -rf chibicc codegen.c tmp* test/*.s test/*.exe minilua *.dyo
 	find * -type f '(' -name '*~' -o -name '*.o' ')' -exec rm {} ';'
 
-.PHONY: test clean test-stage2
+.PHONY: test clean test-stage2 dumpdyo

alloc.c

@@ -0,0 +1,95 @@
+#include "chibicc.h"
+
+#ifdef _MSC_VER
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
+
+static void* allmem;
+static void* current_alloc_pointer;
+
+#define HEAP_SIZE (256<<20)
+
+void bumpcalloc_init(void) {
+  allmem = allocate_writable_memory(HEAP_SIZE);
+  current_alloc_pointer = allmem;
+}
+
+void* bumpcalloc(size_t num, size_t size) {
+  size_t toalloc = align_to(num * size, 8);
+  void* ret = current_alloc_pointer;
+  current_alloc_pointer += toalloc;
+  if (current_alloc_pointer > allmem + HEAP_SIZE) {
+    fprintf(stderr, "heap exhausted");
+    abort();
+  }
+  memset(ret, 0, toalloc);
+  return ret;
+}
+
+void* bumplamerealloc(void* old, size_t old_size, size_t new_size) {
+  void* newptr = bumpcalloc(1, new_size);
+  memcpy(newptr, old, MIN(old_size, new_size));
+  return newptr;
+}
+
+void bumpcalloc_reset(void) {
+  free_executable_memory(allmem, HEAP_SIZE);
+  allmem = NULL;
+  current_alloc_pointer = NULL;
+}
+
+void* aligned_allocate(size_t size, size_t alignment) {
+#ifdef _MSC_VER
+  return _aligned_malloc(size, alignment);
+#else
+  return aligned_alloc(alignment, size);
+#endif
+}
+
+// Allocates RW memory of given size and returns a pointer to it. On failure,
+// prints out the error and returns NULL. Unlike malloc, the memory is allocated
+// on a page boundary so it's suitable for calling mprotect.
+void* allocate_writable_memory(size_t size) {
+#ifdef _MSC_VER
+  void* p =
+      VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
+  if (!p) {
+    fprintf(stderr, "VirtualAlloc failed");
+    return NULL;
+  }
+  return p;
+#else
+  void* ptr =
+      mmap(0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (ptr == (void*)-1) {
+    perror("mmap");
+    return NULL;
+  }
+  return ptr;
+#endif
+}
+
+// Sets a RX permission on the given memory, which must be page-aligned. Returns
+// 0 on success. On failure, prints out the error and returns -1.
+bool make_memory_executable(void* m, size_t size) {
+#ifdef _MSC_VER
+  // TODO: alloc as non-execute
+  return true;
+#else
+  if (mprotect(m, size, PROT_READ | PROT_EXEC) == -1) {
+    perror("mprotect");
+    return false;
+  }
+  return true;
+#endif
+}
+
+void free_executable_memory(void* p, size_t size) {
+#ifdef _MSC_VER
+  VirtualFree(p, size, MEM_RELEASE);
+#else
+  munmap(p, size);
+#endif
+}