Add windows implementation of wasm2c runtime (#1843)

All tests are now passing with cl.exe under x64. With x86 there are some test failure that I believe relate
the use of the x87 registers to pass floating point numbers. I suggest we look into fixing those as a followup.

Split out from #1833

3 files changed, 103 insertions, 28 deletions

diff --git a/wasm2c/examples/fac/Makefile b/wasm2c/examples/fac/Makefile
index caf32e24..a5179a71 100644
--- a/wasm2c/examples/fac/Makefile
+++ b/wasm2c/examples/fac/Makefile
@@ -6,7 +6,7 @@ all: fac
 clean:
 	rm -rf fac fac.wasm fac.c *.o
 
-fac: main.o fac.o ../../wasm-rt-impl.o
+fac: main.o fac.o ../../wasm-rt-impl.o -lm
 
 fac.wasm: fac.wat ../../../bin/wat2wasm
 	../../../bin/wat2wasm $< -o $@
diff --git a/wasm2c/examples/fac/fac.c b/wasm2c/examples/fac/fac.c
index eeb28d9f..9ac9522c 100644
--- a/wasm2c/examples/fac/fac.c
+++ b/wasm2c/examples/fac/fac.c
@@ -3,8 +3,6 @@
 #include <string.h>
 
 #include "fac.h"
-#define UNLIKELY(x) __builtin_expect(!!(x), 0)
-#define LIKELY(x) __builtin_expect(!!(x), 1)
 
 #define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0)
 
@@ -22,13 +20,13 @@
        || TRAP(CALL_INDIRECT)                        \
        , ((t)table.data[x].func)(__VA_ARGS__))
 
-#define RANGE_CHECK(mem, a, t) \
-  if (UNLIKELY((a) + sizeof(t) > mem->size)) TRAP(OOB)
+#define RANGE_CHECK(mem, offset, len) \
+  if (UNLIKELY(offset + (uint64_t)len > mem->size)) TRAP(OOB)
 
 #if WASM_RT_MEMCHECK_SIGNAL_HANDLER
 #define MEMCHECK(mem, a, t)
 #else
-#define MEMCHECK(mem, a, t) RANGE_CHECK(mem, a, t)
+#define MEMCHECK(mem, a, t) RANGE_CHECK(mem, a, sizeof(t))
 #endif
 
 #if WABT_BIG_ENDIAN
@@ -42,45 +40,48 @@ static inline void load_data(void *dest, const void *src, size_t n) {
     dest_chars[n - i - 1] = cursor;
   }
 }
-#define LOAD_DATA(m, o, i, s) do {              \
-    RANGE_CHECK((&m), m.size - o - s, char[s]); \
+#define LOAD_DATA(m, o, i, s)                   \
+  do {                                          \
+    RANGE_CHECK((&m), m.size - o - s, s);       \
     load_data(&(m.data[m.size - o - s]), i, s); \
   } while (0)
-#define DEFINE_LOAD(name, t1, t2, t3)                                                 \
-  static inline t3 name(wasm_rt_memory_t* mem, u64 addr) {                            \
-    MEMCHECK(mem, addr, t1);                                                          \
-    t1 result;                                                                        \
-    __builtin_memcpy(&result, &mem->data[mem->size - addr - sizeof(t1)], sizeof(t1)); \
-    return (t3)(t2)result;                                                            \
+#define DEFINE_LOAD(name, t1, t2, t3)                                  \
+  static inline t3 name(wasm_rt_memory_t* mem, u64 addr) {             \
+    MEMCHECK(mem, addr, t1);                                           \
+    t1 result;                                                         \
+    wasm_rt_memcpy(&result, &mem->data[mem->size - addr - sizeof(t1)], \
+                   sizeof(t1));                                        \
+    return (t3)(t2)result;                                             \
   }
 
-#define DEFINE_STORE(name, t1, t2)                                                     \
-  static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) {                 \
-    MEMCHECK(mem, addr, t1);                                                           \
-    t1 wrapped = (t1)value;                                                            \
-    __builtin_memcpy(&mem->data[mem->size - addr - sizeof(t1)], &wrapped, sizeof(t1)); \
+#define DEFINE_STORE(name, t1, t2)                                      \
+  static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) {  \
+    MEMCHECK(mem, addr, t1);                                            \
+    t1 wrapped = (t1)value;                                             \
+    wasm_rt_memcpy(&mem->data[mem->size - addr - sizeof(t1)], &wrapped, \
+                   sizeof(t1));                                         \
   }
 #else
 static inline void load_data(void *dest, const void *src, size_t n) {
   memcpy(dest, src, n);
 }
 #define LOAD_DATA(m, o, i, s) do { \
-    RANGE_CHECK((&m), o, char[s]); \
+    RANGE_CHECK((&m), o, s); \
     load_data(&(m.data[o]), i, s); \
   } while (0)
-#define DEFINE_LOAD(name, t1, t2, t3)                        \
-  static inline t3 name(wasm_rt_memory_t* mem, u64 addr) {   \
-    MEMCHECK(mem, addr, t1);                                 \
-    t1 result;                                               \
-    __builtin_memcpy(&result, &mem->data[addr], sizeof(t1)); \
-    return (t3)(t2)result;                                   \
+#define DEFINE_LOAD(name, t1, t2, t3)                      \
+  static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \
+    MEMCHECK(mem, addr, t1);                               \
+    t1 result;                                             \
+    wasm_rt_memcpy(&result, &mem->data[addr], sizeof(t1)); \
+    return (t3)(t2)result;                                 \
   }
 
 #define DEFINE_STORE(name, t1, t2)                                     \
   static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) { \
     MEMCHECK(mem, addr, t1);                                           \
     t1 wrapped = (t1)value;                                            \
-    __builtin_memcpy(&mem->data[addr], &wrapped, sizeof(t1));          \
+    wasm_rt_memcpy(&mem->data[addr], &wrapped, sizeof(t1));            \
   }
 #endif
 
@@ -108,6 +109,78 @@ DEFINE_STORE(i64_store8, u8, u64)
 DEFINE_STORE(i64_store16, u16, u64)
 DEFINE_STORE(i64_store32, u32, u64)
 
+#if defined(_MSC_VER)
+
+#include <intrin.h>
+
+// Adapted from https://github.com/nemequ/portable-snippets/blob/master/builtin/builtin.h
+
+static inline int I64_CLZ(unsigned long long v) {
+  unsigned long r = 0;
+#if defined(_M_AMD64) || defined(_M_ARM)
+    if (_BitScanReverse64(&r, v)) {
+      return 63 - r;
+    }
+#else
+    if (_BitScanReverse(&r, (unsigned long) (v >> 32))) {
+      return 31 - r;
+    } else if (_BitScanReverse(&r, (unsigned long) v)) {
+      return 63 - r;
+    }
+#endif
+  return 64;
+}
+
+static inline int I32_CLZ(unsigned long v) {
+  unsigned long r = 0;
+  if (_BitScanReverse(&r, v)) {
+    return 31 - r;
+  }
+  return 32;
+}
+
+static inline int I64_CTZ(unsigned long long v) {
+  if (!v) {
+    return 64;
+  }
+  unsigned long r = 0;
+#if defined(_M_AMD64) || defined(_M_ARM)
+    _BitScanForward64(&r, v);
+    return (int) r;
+#else
+    if (_BitScanForward(&r, (unsigned int) (v))) {
+      return (int) (r);
+    }
+
+    _BitScanForward(&r, (unsigned int) (v >> 32));
+    return (int) (r + 32);
+#endif
+}
+
+static inline int I32_CTZ(unsigned long v) {
+  if (!v) {
+    return 32;
+  }
+  unsigned long r = 0;
+  _BitScanForward(&r, v);
+  return (int) r;
+}
+
+#define POPCOUNT_DEFINE_PORTABLE(f_n, T)                    \
+  static inline u32 f_n(T x) {                              \
+    x = x - ((x >> 1) & (T)~(T)0/3);                        \
+    x = (x & (T)~(T)0/15*3) + ((x >> 2) & (T)~(T)0/15*3);   \
+    x = (x + (x >> 4)) & (T)~(T)0/255*15;                   \
+    return (T)(x * ((T)~(T)0/255)) >> (sizeof(T) - 1) * 8;  \
+  }
+
+POPCOUNT_DEFINE_PORTABLE(I32_POPCNT, u32)
+POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)
+
+#undef POPCOUNT_DEFINE_PORTABLE
+
+#else
+
 #define I32_CLZ(x) ((x) ? __builtin_clz(x) : 32)
 #define I64_CLZ(x) ((x) ? __builtin_clzll(x) : 64)
 #define I32_CTZ(x) ((x) ? __builtin_ctz(x) : 32)
@@ -115,6 +188,8 @@ DEFINE_STORE(i64_store32, u32, u64)
 #define I32_POPCNT(x) (__builtin_popcount(x))
 #define I64_POPCNT(x) (__builtin_popcountll(x))
 
+#endif
+
 #define DIV_S(ut, min, x, y)                                 \
    ((UNLIKELY((y) == 0)) ?                TRAP(DIV_BY_ZERO)  \
   : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \
diff --git a/wasm2c/examples/rot13/Makefile b/wasm2c/examples/rot13/Makefile
index b58db6be..5e5f5205 100644
--- a/wasm2c/examples/rot13/Makefile
+++ b/wasm2c/examples/rot13/Makefile
@@ -6,7 +6,7 @@ all: rot13
 clean:
 	rm -rf rot13 rot13.wasm rot13.c *.o
 
-rot13: main.o rot13.o ../../wasm-rt-impl.o ../../wasm-rt-os-unix.o -lm
+rot13: main.o rot13.o ../../wasm-rt-impl.o -lm
 
 rot13.wasm: rot13.wat ../../../bin/wat2wasm
 	../../../bin/wat2wasm $< -o $@