Support Windows x64 calling convention

- Can somewhat-parse MSVC runtime and common Windows SDK CRT headers
  (but windows.h not attempted yet). Some important things are ignored
  though, notably pragma pack and all __declspecs.
- All self-tests pass for both calling convention styles.
- Calls of integer, floating, struct pass/return work, as do varargs,
  using the stdargs.h/vadefs.h style of MSVC for compatibility.
- Ported from clang/gcc-reliant C11 to MSVC's flavour of somewhat
  annoying C99-ish.
- Updated test code to deal with sizeof(long) == 4 on Windows.
- long double are passed around as 8 byte as per Windows and treated as
  (8 byte) doubles rather than 16 and using the x87 stack as on SysV.
  I'm not totally sure if this matches MSVC or not, but I don't have a
  lot of use for long double.
- .pdata/.xdata RUNTIME_FUNCTIONs are not yet generated and registered,
  that will a subsequent change.

Author: sgraham

.gitignore

@@ -13,4 +13,5 @@ tags
 objconv.exe
 test/x.c
 minilua
-codegen.c
+codegen.linux.c
+codegen.win32.c

Makefile

@@ -1,59 +1,10 @@
-CFLAGS=-std=c11 -g -fno-common -Wall -Werror -Wno-switch -pthread -Wunreachable-code -Wmisleading-indentation
+include makefile.shared
 
-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)
+CFLAGS=-std=c11 -g -fno-common -Wall -Werror -Wno-switch -pthread
+
+SRCS += codegen.linux.c
 
-# XXX:
-# test/asm.c
-#   dyibicc 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
+OBJS=$(SRCS:.c=.o)
 
 dyibicc: $(OBJS)
 	$(CC) $(CFLAGS) -o $@ $^ -ldl $(LDFLAGS)
@@ -66,7 +17,7 @@ $(OBJS): dyibicc.h
 minilua: dynasm/minilua.c
 	$(CC) $(CFLAGS) -o $@ $^ -lm
 
-codegen.c: codegen.in.c minilua
+codegen.linux.c: codegen.in.c minilua
 	./minilua dynasm/dynasm.lua -o $@ codegen.in.c
 
 test: $(TEST_SRCS) dyibicc
@@ -75,8 +26,8 @@ test: $(TEST_SRCS) dyibicc
 # Misc.
 
 clean:
-	rm -rf dyibicc dumpdyo codegen.c tmp* test/*.s test/*.exe minilua minilua.exe *.dyo *.exe *.pdb *.ilk
+	rm -rf dyibicc dumpdyo codegen.c test/*.s test/*.exe minilua minilua.exe *.dyo *.exe *.pdb *.ilk
 	find * -type f '(' -name '*~' -o -name '*.o' ')' -exec rm {} ';'
 	clang-format -i *.c *.h
 
-.PHONY: test clean test-stage2 dumpdyo
+.PHONY: test clean

README.md

@@ -6,12 +6,18 @@ generates machine code via [DynASM](https://luajit.org/dynasm.html).
 I renamed it from chibicc to dyibicc to avoid confusion between the two. But the
 code still overwhelmingly follows Rui's model and style.
 
-Build and test with:
+Build and test on Linux with:
 
 ```
 $ make
 $ make test
 ```
 
-Currently only supports Linux and x64. (It will build on Windows where it can
-generate .dyos, but the calling convention is always SysV so they can't be run.)
+or on Windows (from a VS x64 cmd):
+
+```
+> make
+> make test
+```
+
+Currently only supports Linux or Windows, and x64 only.

alloc.c

@@ -1,28 +1,36 @@
 #include "dyibicc.h"
 
-#ifdef _MSC_VER
+#if X64WIN
 #include <windows.h>
 #else
 #include <sys/mman.h>
 #endif
 
-static void* allmem;
-static void* current_alloc_pointer;
+static char* allmem;
+static char* current_alloc_pointer;
 
 #define HEAP_SIZE (256 << 20)
 
+// Reports an error and exit.
+void error(char* fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  fprintf(stderr, "\n");
+  exit(1);
+}
+
 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;
+  size_t toalloc = align_to((int)(num * size), 8);
+  char* ret = current_alloc_pointer;
   current_alloc_pointer += toalloc;
   if (current_alloc_pointer > allmem + HEAP_SIZE) {
-    fprintf(stderr, "heap exhausted");
-    abort();
+    error("heap exhausted");
   }
   memset(ret, 0, toalloc);
   return ret;
@@ -41,7 +49,7 @@ void bumpcalloc_reset(void) {
 }
 
 void* aligned_allocate(size_t size, size_t alignment) {
-#ifdef _MSC_VER
+#if X64WIN
   return _aligned_malloc(size, alignment);
 #else
   return aligned_alloc(alignment, size);
@@ -52,11 +60,10 @@ void* aligned_allocate(size_t size, size_t alignment) {
 // 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
+#if X64WIN
   void* p = VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
   if (!p) {
-    fprintf(stderr, "VirtualAlloc failed");
-    return NULL;
+    error("VirtualAlloc failed: 0x%x\n", GetLastError());
   }
   return p;
 #else
@@ -72,7 +79,9 @@ void* allocate_writable_memory(size_t size) {
 // 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
+#if X64WIN
+  (void)m;
+  (void)size;
   // TODO: alloc as non-execute
   return true;
 #else
@@ -85,7 +94,7 @@ bool make_memory_executable(void* m, size_t size) {
 }
 
 void free_executable_memory(void* p, size_t size) {
-#ifdef _MSC_VER
+#if X64WIN
   VirtualFree(p, size, MEM_RELEASE);
 #else
   munmap(p, size);