wasm2c: simplify handling of templated code (#1940)

Store templated wasm2c code as .h/.c; build templates on demand

11 files changed, 39 insertions, 460 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1fe79b8d..dac8511e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -468,9 +468,29 @@ if (BUILD_TOOLS)
   )
 
   # wasm2c
+  set(TEMPLATE_CMAKE ${WABT_SOURCE_DIR}/scripts/gen-wasm2c-templates.cmake)
+
+  # wasm2c generated code templates
+  add_custom_command(
+    OUTPUT wasm2c_header_top.cc wasm2c_header_bottom.cc wasm2c_source_includes.cc wasm2c_source_declarations.cc
+
+    COMMAND ${CMAKE_COMMAND} -D out="wasm2c_header_top.cc" -D in="${WABT_SOURCE_DIR}/src/template/wasm2c.top.h" -D symbol="s_header_top" -P ${TEMPLATE_CMAKE}
+    COMMAND ${CMAKE_COMMAND} -D out="wasm2c_header_bottom.cc" -D in="${WABT_SOURCE_DIR}/src/template/wasm2c.bottom.h" -D symbol="s_header_bottom" -P ${TEMPLATE_CMAKE}
+    COMMAND ${CMAKE_COMMAND} -D out="wasm2c_source_includes.cc" -D in="${WABT_SOURCE_DIR}/src/template/wasm2c.includes.c" -D symbol="s_source_includes" -P ${TEMPLATE_CMAKE}
+    COMMAND ${CMAKE_COMMAND} -D out="wasm2c_source_declarations.cc" -D in="${WABT_SOURCE_DIR}/src/template/wasm2c.declarations.c" -D symbol="s_source_declarations" -P ${TEMPLATE_CMAKE}
+
+    DEPENDS ${WABT_SOURCE_DIR}/src/template/wasm2c.top.h
+    ${WABT_SOURCE_DIR}/src/template/wasm2c.bottom.h
+    ${WABT_SOURCE_DIR}/src/template/wasm2c.includes.c
+    ${WABT_SOURCE_DIR}/src/template/wasm2c.declarations.c
+    )
+
+  add_library(cwriter-template wasm2c_header_top.cc wasm2c_header_bottom.cc wasm2c_source_includes.cc wasm2c_source_declarations.cc)
+
   wabt_executable(
     NAME wasm2c
     SOURCES src/tools/wasm2c.cc src/c-writer.cc
+    LIBS cwriter-template
     INSTALL
   )
 
diff --git a/Makefile b/Makefile
index 7915598b..78d1ef4c 100644
--- a/Makefile
+++ b/Makefile
@@ -144,16 +144,10 @@ update-gperf: src/prebuilt/lexer-keywords.cc
 src/prebuilt/lexer-keywords.cc: src/lexer-keywords.txt
 	gperf -m 50 -L C++ -N InWordSet -E -t -c --output-file=$@ $<
 
-.PHONY: update-wasm2c
-update-wasm2c: src/prebuilt/wasm2c.include.c src/prebuilt/wasm2c.include.h
+.PHONY: update-wasm2c-fac
+update-wasm2c-fac:
 	make -C wasm2c/examples/fac
 
-src/prebuilt/wasm2c.include.c: src/wasm2c.c.tmpl
-	src/wasm2c_tmpl.py -o $@ $<
-
-src/prebuilt/wasm2c.include.h: src/wasm2c.h.tmpl
-	src/wasm2c_tmpl.py -o $@ $<
-
 .PHONY: demo
 demo: emscripten-release
 	cp out/emscripten/Release/libwabt.js docs/demo
diff --git a/scripts/gen-wasm2c-templates.cmake b/scripts/gen-wasm2c-templates.cmake
new file mode 100644
index 00000000..99a61d03
--- /dev/null
+++ b/scripts/gen-wasm2c-templates.cmake
@@ -0,0 +1,4 @@
+# https://stackoverflow.com/a/47801116
+file(READ ${in} content)
+set(content "const char* ${symbol} = R\"w2c_template(${content})w2c_template\";")
+file(WRITE ${out} "${content}")
diff --git a/src/c-writer.cc b/src/c-writer.cc
index ce247deb..e11d5a49 100644
--- a/src/c-writer.cc
+++ b/src/c-writer.cc
@@ -33,6 +33,12 @@
 
 #define UNIMPLEMENTED(x) printf("unimplemented: %s\n", (x)), abort()
 
+// code to be inserted into the generated output
+extern const char* s_header_top;
+extern const char* s_header_bottom;
+extern const char* s_source_includes;
+extern const char* s_source_declarations;
+
 namespace wabt {
 
 namespace {
@@ -294,14 +300,6 @@ class CWriter {
 
 static const char kImplicitFuncLabel[] = "$Bfunc";
 
-#define SECTION_NAME(x) s_header_##x
-#include "src/prebuilt/wasm2c.include.h"
-#undef SECTION_NAME
-
-#define SECTION_NAME(x) s_source_##x
-#include "src/prebuilt/wasm2c.include.c"
-#undef SECTION_NAME
-
 size_t CWriter::MarkTypeStack() const {
   return type_stack_.size();
 }
@@ -2390,6 +2388,7 @@ void CWriter::WriteCHeader() {
 
 void CWriter::WriteCSource() {
   stream_ = c_stream_;
+  Write("/* Automatically generated by wasm2c */", Newline());
   WriteSourceTop();
   WriteFuncTypes();
   WriteFuncDeclarations();
diff --git a/src/prebuilt/wasm2c.include.c b/src/prebuilt/wasm2c.include.c
deleted file mode 100644
index 85ac55cb..00000000
--- a/src/prebuilt/wasm2c.include.c
+++ /dev/null
@@ -1,324 +0,0 @@
-/* Generated from 'wasm2c.c.tmpl' by wasm2c_tmpl.py, do not edit! */
-const char SECTION_NAME(includes)[] =
-"/* Automatically generated by wasm2c */\n"
-"#include <math.h>\n"
-"#include <string.h>\n"
-;
-
-const char SECTION_NAME(declarations)[] =
-"\n"
-"#define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0)\n"
-"\n"
-"#if WASM_RT_MEMCHECK_SIGNAL_HANDLER\n"
-"#define FUNC_PROLOGUE\n"
-"\n"
-"#define FUNC_EPILOGUE\n"
-"#else\n"
-"#define FUNC_PROLOGUE                                            \\\n"
-"  if (++wasm_rt_call_stack_depth > WASM_RT_MAX_CALL_STACK_DEPTH) \\\n"
-"    TRAP(EXHAUSTION);\n"
-"\n"
-"#define FUNC_EPILOGUE --wasm_rt_call_stack_depth\n"
-"#endif\n"
-"\n"
-"#define UNREACHABLE TRAP(UNREACHABLE)\n"
-"\n"
-"#define CALL_INDIRECT(table, t, ft, x, ...)             \\\n"
-"  (LIKELY((x) < table.size && table.data[x].func &&     \\\n"
-"          table.data[x].func_type == func_types[ft]) || \\\n"
-"       TRAP(CALL_INDIRECT),                             \\\n"
-"   ((t)table.data[x].func)(__VA_ARGS__))\n"
-"\n"
-"#define RANGE_CHECK(mem, offset, len)               \\\n"
-"  if (UNLIKELY(offset + (uint64_t)len > mem->size)) \\\n"
-"    TRAP(OOB);\n"
-"\n"
-"#if WASM_RT_MEMCHECK_SIGNAL_HANDLER\n"
-"#define MEMCHECK(mem, a, t)\n"
-"#else\n"
-"#define MEMCHECK(mem, a, t) RANGE_CHECK(mem, a, sizeof(t))\n"
-"#endif\n"
-"\n"
-"#if WABT_BIG_ENDIAN\n"
-"static inline void load_data(void* dest, const void* src, size_t n) {\n"
-"  size_t i = 0;\n"
-"  u8* dest_chars = dest;\n"
-"  memcpy(dest, src, n);\n"
-"  for (i = 0; i < (n >> 1); i++) {\n"
-"    u8 cursor = dest_chars[i];\n"
-"    dest_chars[i] = dest_chars[n - i - 1];\n"
-"    dest_chars[n - i - 1] = cursor;\n"
-"  }\n"
-"}\n"
-"#define LOAD_DATA(m, o, i, s)                   \\\n"
-"  do {                                          \\\n"
-"    RANGE_CHECK((&m), m.size - o - s, s);       \\\n"
-"    load_data(&(m.data[m.size - o - s]), i, s); \\\n"
-"  } while (0)\n"
-"#define DEFINE_LOAD(name, t1, t2, t3)                                  \\\n"
-"  static inline t3 name(wasm_rt_memory_t* mem, u64 addr) {             \\\n"
-"    MEMCHECK(mem, addr, t1);                                           \\\n"
-"    t1 result;                                                         \\\n"
-"    wasm_rt_memcpy(&result, &mem->data[mem->size - addr - sizeof(t1)], \\\n"
-"                   sizeof(t1));                                        \\\n"
-"    return (t3)(t2)result;                                             \\\n"
-"  }\n"
-"\n"
-"#define DEFINE_STORE(name, t1, t2)                                      \\\n"
-"  static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) {  \\\n"
-"    MEMCHECK(mem, addr, t1);                                            \\\n"
-"    t1 wrapped = (t1)value;                                             \\\n"
-"    wasm_rt_memcpy(&mem->data[mem->size - addr - sizeof(t1)], &wrapped, \\\n"
-"                   sizeof(t1));                                         \\\n"
-"  }\n"
-"#else\n"
-"static inline void load_data(void* dest, const void* src, size_t n) {\n"
-"  memcpy(dest, src, n);\n"
-"}\n"
-"#define LOAD_DATA(m, o, i, s)      \\\n"
-"  do {                             \\\n"
-"    RANGE_CHECK((&m), o, s);       \\\n"
-"    load_data(&(m.data[o]), i, s); \\\n"
-"  } while (0)\n"
-"#define DEFINE_LOAD(name, t1, t2, t3)                      \\\n"
-"  static inline t3 name(wasm_rt_memory_t* mem, u64 addr) { \\\n"
-"    MEMCHECK(mem, addr, t1);                               \\\n"
-"    t1 result;                                             \\\n"
-"    wasm_rt_memcpy(&result, &mem->data[addr], sizeof(t1)); \\\n"
-"    return (t3)(t2)result;                                 \\\n"
-"  }\n"
-"\n"
-"#define DEFINE_STORE(name, t1, t2)                                     \\\n"
-"  static inline void name(wasm_rt_memory_t* mem, u64 addr, t2 value) { \\\n"
-"    MEMCHECK(mem, addr, t1);                                           \\\n"
-"    t1 wrapped = (t1)value;                                            \\\n"
-"    wasm_rt_memcpy(&mem->data[addr], &wrapped, sizeof(t1));            \\\n"
-"  }\n"
-"#endif\n"
-"\n"
-"DEFINE_LOAD(i32_load, u32, u32, u32)\n"
-"DEFINE_LOAD(i64_load, u64, u64, u64)\n"
-"DEFINE_LOAD(f32_load, f32, f32, f32)\n"
-"DEFINE_LOAD(f64_load, f64, f64, f64)\n"
-"DEFINE_LOAD(i32_load8_s, s8, s32, u32)\n"
-"DEFINE_LOAD(i64_load8_s, s8, s64, u64)\n"
-"DEFINE_LOAD(i32_load8_u, u8, u32, u32)\n"
-"DEFINE_LOAD(i64_load8_u, u8, u64, u64)\n"
-"DEFINE_LOAD(i32_load16_s, s16, s32, u32)\n"
-"DEFINE_LOAD(i64_load16_s, s16, s64, u64)\n"
-"DEFINE_LOAD(i32_load16_u, u16, u32, u32)\n"
-"DEFINE_LOAD(i64_load16_u, u16, u64, u64)\n"
-"DEFINE_LOAD(i64_load32_s, s32, s64, u64)\n"
-"DEFINE_LOAD(i64_load32_u, u32, u64, u64)\n"
-"DEFINE_STORE(i32_store, u32, u32)\n"
-"DEFINE_STORE(i64_store, u64, u64)\n"
-"DEFINE_STORE(f32_store, f32, f32)\n"
-"DEFINE_STORE(f64_store, f64, f64)\n"
-"DEFINE_STORE(i32_store8, u8, u32)\n"
-"DEFINE_STORE(i32_store16, u16, u32)\n"
-"DEFINE_STORE(i64_store8, u8, u64)\n"
-"DEFINE_STORE(i64_store16, u16, u64)\n"
-"DEFINE_STORE(i64_store32, u32, u64)\n"
-"\n"
-"#if defined(_MSC_VER)\n"
-"\n"
-"#include <intrin.h>\n"
-"\n"
-"// Adapted from\n"
-"// https://github.com/nemequ/portable-snippets/blob/master/builtin/builtin.h\n"
-"\n"
-"static inline int I64_CLZ(unsigned long long v) {\n"
-"  unsigned long r = 0;\n"
-"#if defined(_M_AMD64) || defined(_M_ARM)\n"
-"  if (_BitScanReverse64(&r, v)) {\n"
-"    return 63 - r;\n"
-"  }\n"
-"#else\n"
-"  if (_BitScanReverse(&r, (unsigned long)(v >> 32))) {\n"
-"    return 31 - r;\n"
-"  } else if (_BitScanReverse(&r, (unsigned long)v)) {\n"
-"    return 63 - r;\n"
-"  }\n"
-"#endif\n"
-"  return 64;\n"
-"}\n"
-"\n"
-"static inline int I32_CLZ(unsigned long v) {\n"
-"  unsigned long r = 0;\n"
-"  if (_BitScanReverse(&r, v)) {\n"
-"    return 31 - r;\n"
-"  }\n"
-"  return 32;\n"
-"}\n"
-"\n"
-"static inline int I64_CTZ(unsigned long long v) {\n"
-"  if (!v) {\n"
-"    return 64;\n"
-"  }\n"
-"  unsigned long r = 0;\n"
-"#if defined(_M_AMD64) || defined(_M_ARM)\n"
-"  _BitScanForward64(&r, v);\n"
-"  return (int)r;\n"
-"#else\n"
-"  if (_BitScanForward(&r, (unsigned int)(v))) {\n"
-"    return (int)(r);\n"
-"  }\n"
-"\n"
-"  _BitScanForward(&r, (unsigned int)(v >> 32));\n"
-"  return (int)(r + 32);\n"
-"#endif\n"
-"}\n"
-"\n"
-"static inline int I32_CTZ(unsigned long v) {\n"
-"  if (!v) {\n"
-"    return 32;\n"
-"  }\n"
-"  unsigned long r = 0;\n"
-"  _BitScanForward(&r, v);\n"
-"  return (int)r;\n"
-"}\n"
-"\n"
-"#define POPCOUNT_DEFINE_PORTABLE(f_n, T)                            \\\n"
-"  static inline u32 f_n(T x) {                                      \\\n"
-"    x = x - ((x >> 1) & (T) ~(T)0 / 3);                             \\\n"
-"    x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3); \\\n"
-"    x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15;                      \\\n"
-"    return (T)(x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;       \\\n"
-"  }\n"
-"\n"
-"POPCOUNT_DEFINE_PORTABLE(I32_POPCNT, u32)\n"
-"POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)\n"
-"\n"
-"#undef POPCOUNT_DEFINE_PORTABLE\n"
-"\n"
-"#else\n"
-"\n"
-"#define I32_CLZ(x) ((x) ? __builtin_clz(x) : 32)\n"
-"#define I64_CLZ(x) ((x) ? __builtin_clzll(x) : 64)\n"
-"#define I32_CTZ(x) ((x) ? __builtin_ctz(x) : 32)\n"
-"#define I64_CTZ(x) ((x) ? __builtin_ctzll(x) : 64)\n"
-"#define I32_POPCNT(x) (__builtin_popcount(x))\n"
-"#define I64_POPCNT(x) (__builtin_popcountll(x))\n"
-"\n"
-"#endif\n"
-"\n"
-"#define DIV_S(ut, min, x, y)                                      \\\n"
-"  ((UNLIKELY((y) == 0))                                           \\\n"
-"       ? TRAP(DIV_BY_ZERO)                                        \\\n"
-"       : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \\\n"
-"                                             : (ut)((x) / (y)))\n"
-"\n"
-"#define REM_S(ut, min, x, y) \\\n"
-"  ((UNLIKELY((y) == 0))      \\\n"
-"       ? TRAP(DIV_BY_ZERO)   \\\n"
-"       : (UNLIKELY((x) == min && (y) == -1)) ? 0 : (ut)((x) % (y)))\n"
-"\n"
-"#define I32_DIV_S(x, y) DIV_S(u32, INT32_MIN, (s32)x, (s32)y)\n"
-"#define I64_DIV_S(x, y) DIV_S(u64, INT64_MIN, (s64)x, (s64)y)\n"
-"#define I32_REM_S(x, y) REM_S(u32, INT32_MIN, (s32)x, (s32)y)\n"
-"#define I64_REM_S(x, y) REM_S(u64, INT64_MIN, (s64)x, (s64)y)\n"
-"\n"
-"#define DIVREM_U(op, x, y) \\\n"
-"  ((UNLIKELY((y) == 0)) ? TRAP(DIV_BY_ZERO) : ((x)op(y)))\n"
-"\n"
-"#define DIV_U(x, y) DIVREM_U(/, x, y)\n"
-"#define REM_U(x, y) DIVREM_U(%, x, y)\n"
-"\n"
-"#define ROTL(x, y, mask) \\\n"
-"  (((x) << ((y) & (mask))) | ((x) >> (((mask) - (y) + 1) & (mask))))\n"
-"#define ROTR(x, y, mask) \\\n"
-"  (((x) >> ((y) & (mask))) | ((x) << (((mask) - (y) + 1) & (mask))))\n"
-"\n"
-"#define I32_ROTL(x, y) ROTL(x, y, 31)\n"
-"#define I64_ROTL(x, y) ROTL(x, y, 63)\n"
-"#define I32_ROTR(x, y) ROTR(x, y, 31)\n"
-"#define I64_ROTR(x, y) ROTR(x, y, 63)\n"
-"\n"
-"#define FMIN(x, y)                                                     \\\n"
-"  ((UNLIKELY((x) != (x)))                                              \\\n"
-"       ? NAN                                                           \\\n"
-"       : (UNLIKELY((y) != (y)))                                        \\\n"
-"             ? NAN                                                     \\\n"
-"             : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? x : y) \\\n"
-"                                                : (x < y) ? x : y)\n"
-"\n"
-"#define FMAX(x, y)                                                     \\\n"
-"  ((UNLIKELY((x) != (x)))                                              \\\n"
-"       ? NAN                                                           \\\n"
-"       : (UNLIKELY((y) != (y)))                                        \\\n"
-"             ? NAN                                                     \\\n"
-"             : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? y : x) \\\n"
-"                                                : (x > y) ? x : y)\n"
-"\n"
-"#define TRUNC_S(ut, st, ft, min, minop, max, x)                           \\\n"
-"  ((UNLIKELY((x) != (x)))                                                 \\\n"
-"       ? TRAP(INVALID_CONVERSION)                                         \\\n"
-"       : (UNLIKELY(!((x)minop(min) && (x) < (max)))) ? TRAP(INT_OVERFLOW) \\\n"
-"                                                     : (ut)(st)(x))\n"
-"\n"
-"#define I32_TRUNC_S_F32(x) \\\n"
-"  TRUNC_S(u32, s32, f32, (f32)INT32_MIN, >=, 2147483648.f, x)\n"
-"#define I64_TRUNC_S_F32(x) \\\n"
-"  TRUNC_S(u64, s64, f32, (f32)INT64_MIN, >=, (f32)INT64_MAX, x)\n"
-"#define I32_TRUNC_S_F64(x) \\\n"
-"  TRUNC_S(u32, s32, f64, -2147483649., >, 2147483648., x)\n"
-"#define I64_TRUNC_S_F64(x) \\\n"
-"  TRUNC_S(u64, s64, f64, (f64)INT64_MIN, >=, (f64)INT64_MAX, x)\n"
-"\n"
-"#define TRUNC_U(ut, ft, max, x)                                          \\\n"
-"  ((UNLIKELY((x) != (x)))                                                \\\n"
-"       ? TRAP(INVALID_CONVERSION)                                        \\\n"
-"       : (UNLIKELY(!((x) > (ft)-1 && (x) < (max)))) ? TRAP(INT_OVERFLOW) \\\n"
-"                                                    : (ut)(x))\n"
-"\n"
-"#define I32_TRUNC_U_F32(x) TRUNC_U(u32, f32, 4294967296.f, x)\n"
-"#define I64_TRUNC_U_F32(x) TRUNC_U(u64, f32, (f32)UINT64_MAX, x)\n"
-"#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, 4294967296., x)\n"
-"#define I64_TRUNC_U_F64(x) TRUNC_U(u64, f64, (f64)UINT64_MAX, x)\n"
-"\n"
-"#define TRUNC_SAT_S(ut, st, ft, min, smin, minop, max, smax, x) \\\n"
-"  ((UNLIKELY((x) != (x)))                                       \\\n"
-"       ? 0                                                      \\\n"
-"       : (UNLIKELY(!((x)minop(min))))                           \\\n"
-"             ? smin                                             \\\n"
-"             : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(st)(x))\n"
-"\n"
-"#define I32_TRUNC_SAT_S_F32(x)                                            \\\n"
-"  TRUNC_SAT_S(u32, s32, f32, (f32)INT32_MIN, INT32_MIN, >=, 2147483648.f, \\\n"
-"              INT32_MAX, x)\n"
-"#define I64_TRUNC_SAT_S_F32(x)                                              \\\n"
-"  TRUNC_SAT_S(u64, s64, f32, (f32)INT64_MIN, INT64_MIN, >=, (f32)INT64_MAX, \\\n"
-"              INT64_MAX, x)\n"
-"#define I32_TRUNC_SAT_S_F64(x)                                        \\\n"
-"  TRUNC_SAT_S(u32, s32, f64, -2147483649., INT32_MIN, >, 2147483648., \\\n"
-"              INT32_MAX, x)\n"
-"#define I64_TRUNC_SAT_S_F64(x)                                              \\\n"
-"  TRUNC_SAT_S(u64, s64, f64, (f64)INT64_MIN, INT64_MIN, >=, (f64)INT64_MAX, \\\n"
-"              INT64_MAX, x)\n"
-"\n"
-"#define TRUNC_SAT_U(ut, ft, max, smax, x)               \\\n"
-"  ((UNLIKELY((x) != (x))) ? 0                           \\\n"
-"                          : (UNLIKELY(!((x) > (ft)-1))) \\\n"
-"                                ? 0                     \\\n"
-"                                : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(x))\n"
-"\n"
-"#define I32_TRUNC_SAT_U_F32(x) \\\n"
-"  TRUNC_SAT_U(u32, f32, 4294967296.f, UINT32_MAX, x)\n"
-"#define I64_TRUNC_SAT_U_F32(x) \\\n"
-"  TRUNC_SAT_U(u64, f32, (f32)UINT64_MAX, UINT64_MAX, x)\n"
-"#define I32_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u32, f64, 4294967296., UINT32_MAX, x)\n"
-"#define I64_TRUNC_SAT_U_F64(x) \\\n"
-"  TRUNC_SAT_U(u64, f64, (f64)UINT64_MAX, UINT64_MAX, x)\n"
-"\n"
-"#define DEFINE_REINTERPRET(name, t1, t2) \\\n"
-"  static inline t2 name(t1 x) {          \\\n"
-"    t2 result;                           \\\n"
-"    memcpy(&result, &x, sizeof(result)); \\\n"
-"    return result;                       \\\n"
-"  }\n"
-"\n"
-"DEFINE_REINTERPRET(f32_reinterpret_i32, u32, f32)\n"
-"DEFINE_REINTERPRET(i32_reinterpret_f32, f32, u32)\n"
-"DEFINE_REINTERPRET(f64_reinterpret_i64, u64, f64)\n"
-"DEFINE_REINTERPRET(i64_reinterpret_f64, f64, u64)\n"
-;
diff --git a/src/prebuilt/wasm2c.include.h b/src/prebuilt/wasm2c.include.h
deleted file mode 100644
index d1f300b3..00000000
--- a/src/prebuilt/wasm2c.include.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Generated from 'wasm2c.h.tmpl' by wasm2c_tmpl.py, do not edit! */
-const char SECTION_NAME(top)[] =
-"#include <stdint.h>\n"
-"\n"
-"#include \"wasm-rt.h\"\n"
-"\n"
-"/* TODO(binji): only use stdint.h types in header */\n"
-"#ifndef WASM_RT_CORE_TYPES_DEFINED\n"
-"#define WASM_RT_CORE_TYPES_DEFINED\n"
-"typedef uint8_t u8;\n"
-"typedef int8_t s8;\n"
-"typedef uint16_t u16;\n"
-"typedef int16_t s16;\n"
-"typedef uint32_t u32;\n"
-"typedef int32_t s32;\n"
-"typedef uint64_t u64;\n"
-"typedef int64_t s64;\n"
-"typedef float f32;\n"
-"typedef double f64;\n"
-"#endif\n"
-"\n"
-"#ifdef __cplusplus\n"
-"extern \"C\" {\n"
-"#endif\n"
-;
-
-const char SECTION_NAME(bottom)[] =
-"\n"
-"#ifdef __cplusplus\n"
-"}\n"
-"#endif\n"
-;
diff --git a/src/template/wasm2c.bottom.h b/src/template/wasm2c.bottom.h
new file mode 100644
index 00000000..ca8de5b3
--- /dev/null
+++ b/src/template/wasm2c.bottom.h
@@ -0,0 +1,4 @@
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/wasm2c.c.tmpl b/src/template/wasm2c.declarations.c
index ae430453..bd66cedb 100644
--- a/src/wasm2c.c.tmpl
+++ b/src/template/wasm2c.declarations.c
@@ -1,8 +1,3 @@
-%%includes
-/* Automatically generated by wasm2c */
-#include <math.h>
-#include <string.h>
-%%declarations
 
 #define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0)
 
diff --git a/src/template/wasm2c.includes.c b/src/template/wasm2c.includes.c
new file mode 100644
index 00000000..91e7c21d
--- /dev/null
+++ b/src/template/wasm2c.includes.c
@@ -0,0 +1,2 @@
+#include <math.h>
+#include <string.h>
diff --git a/src/wasm2c.h.tmpl b/src/template/wasm2c.top.h
index 774e2e97..5c60191b 100644
--- a/src/wasm2c.h.tmpl
+++ b/src/template/wasm2c.top.h
@@ -1,4 +1,3 @@
-%%top
 #include <stdint.h>
 
 #include "wasm-rt.h"
@@ -21,8 +20,3 @@ typedef double f64;
 #ifdef __cplusplus
 extern "C" {
 #endif
-%%bottom
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/wasm2c_tmpl.py b/src/wasm2c_tmpl.py
deleted file mode 100755
index 0da117a8..00000000
--- a/src/wasm2c_tmpl.py
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright 2018 WebAssembly Community Group participants
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import argparse
-import io
-import os
-import sys
-
-
-def EscapeCString(s):
-    out = ''
-    for b in bytearray(s.encode('utf-8')):
-        if b in (34, 92):
-            # " or \
-            out += '\\' + chr(b)
-        elif b == 10:
-            # newline
-            out += '\\n'
-        elif 32 <= b <= 127:
-            # printable char
-            out += chr(b)
-        else:
-            # non-printable; write as \xab
-            out += '\\x%02x' % b
-
-    return out
-
-
-def main(args):
-    arg_parser = argparse.ArgumentParser()
-    arg_parser.add_argument('-o', '--output', metavar='PATH',
-                            help='output file.')
-    arg_parser.add_argument('file', help='input file.')
-    options = arg_parser.parse_args(args)
-
-    section_name = None
-    output = io.StringIO()
-
-    output.write('/* Generated from \'%s\' by wasm2c_tmpl.py, do not edit! */\n' %
-                 os.path.basename(options.file))
-
-    with open(options.file) as f:
-        for line in f.readlines():
-            if line.startswith('%%'):
-                if section_name is not None:
-                    output.write(';\n\n')
-                section_name = line[2:-1]
-                output.write('const char SECTION_NAME(%s)[] =\n' % section_name)
-            else:
-                output.write('"%s"\n' % EscapeCString(line))
-
-    output.write(';\n')
-    if options.output:
-        with open(options.output, 'w') as outf:
-            outf.write(output.getvalue())
-    else:
-        sys.stdout.write(output.getvalue())
-
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main(sys.argv[1:]))