wasm interpreter

Works by generating an instruction stream for a simple stack machine.

18 files changed, 4423 insertions, 20 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0a71ae39..34a509f6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -137,6 +137,26 @@ set(WASM_WAST_SRCS
 add_executable(wasm-wast ${WASM_WAST_SRCS})
 add_dependencies(everything wasm-wast)
 
+# wasm-interp
+set(WASM_INTERP_SRCS
+  src/wasm-allocator.c
+  src/wasm-binary-reader.c
+  src/wasm-binary-reader-interpreter.c
+  src/wasm-common.c
+  src/wasm-config.c
+  src/wasm-interp.c
+  src/wasm-interpreter.c
+  src/wasm-option-parser.c
+  src/wasm-stack-allocator.c
+  src/wasm-vector.c
+  src/wasm-writer.c
+)
+
+add_executable(wasm-interp ${WASM_INTERP_SRCS})
+add_dependencies(everything wasm-interp)
+target_link_libraries(wasm-interp m)
+
+
 # hexfloat-test
 option(BUILD_TESTS "Build GTest-based tests" ON)
 find_package(Threads)
diff --git a/Makefile b/Makefile
index 88f20952..829c506e 100644
--- a/Makefile
+++ b/Makefile
@@ -31,7 +31,7 @@ COMPILERS := GCC GCC_I686 GCC_FUZZ CLANG
 BUILD_TYPES := DEBUG RELEASE
 SANITIZERS := ASAN MSAN LSAN
 CONFIGS := NORMAL ASAN MSAN LSAN NO_FLEX_BISON NO_TESTS
-EXECUTABLES := sexpr-wasm wasm-wast hexfloat_test
+EXECUTABLES := sexpr-wasm wasm-wast wasm-interp hexfloat_test
 
 # directory names
 GCC_DIR := gcc/
diff --git a/src/wasm-allocator.h b/src/wasm-allocator.h
index f56404dd..7dc81987 100644
--- a/src/wasm-allocator.h
+++ b/src/wasm-allocator.h
@@ -78,6 +78,15 @@ static WASM_INLINE char* wasm_strndup(WasmAllocator* allocator,
   new_s[real_len] = 0;
   return new_s;
 }
+
+static WASM_INLINE WasmStringSlice
+wasm_dup_string_slice(WasmAllocator* allocator, WasmStringSlice str) {
+  WasmStringSlice result;
+  result.start = wasm_strndup(allocator, str.start, str.length);
+  result.length = str.length;
+  return result;
+}
+
 WASM_EXTERN_C_END
 
 #endif /* WASM_ALLOCATOR_H_ */
diff --git a/src/wasm-array.h b/src/wasm-array.h
new file mode 100644
index 00000000..3d8f84c1
--- /dev/null
+++ b/src/wasm-array.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef WASM_ARRAY_H_
+#define WASM_ARRAY_H_
+
+#include <stddef.h>
+
+#include "wasm-allocator.h"
+#include "wasm-common.h"
+
+#define WASM_DEFINE_ARRAY(name, type)                                        \
+  typedef struct type##Array {                                               \
+    type* data;                                                              \
+    size_t size;                                                             \
+  } type##Array;                                                             \
+                                                                             \
+  WASM_EXTERN_C_BEGIN                                                        \
+  static WASM_INLINE void wasm_destroy_##name##_array(                       \
+      struct WasmAllocator* allocator, type##Array* array) WASM_UNUSED;      \
+  static WASM_INLINE WasmResult wasm_new_##name##_array(                     \
+      struct WasmAllocator* allocator, type##Array* array, size_t size)      \
+      WASM_UNUSED;                                                           \
+  WASM_EXTERN_C_END                                                          \
+                                                                             \
+  void wasm_destroy_##name##_array(struct WasmAllocator* allocator,          \
+                                   type##Array* array) {                     \
+    wasm_free(allocator, array->data);                                       \
+  }                                                                          \
+  WasmResult wasm_new_##name##_array(struct WasmAllocator* allocator,        \
+                                     type##Array* array, size_t size) {      \
+    array->size = size;                                                      \
+    array->data =                                                            \
+        wasm_alloc_zero(allocator, size * sizeof(type), WASM_DEFAULT_ALIGN); \
+    return array->data ? WASM_OK : WASM_ERROR;                               \
+  }
+
+#endif /* WASM_ARRAY_H_ */
diff --git a/src/wasm-binary-reader-ast.c b/src/wasm-binary-reader-ast.c
index dd5ba0c4..3c785cef 100644
--- a/src/wasm-binary-reader-ast.c
+++ b/src/wasm-binary-reader-ast.c
@@ -136,14 +136,6 @@ static uint32_t get_num_func_params_and_locals(WasmModule* module,
   return num_params + num_locals;
 }
 
-static WasmStringSlice dup_string_slice(WasmAllocator* allocator,
-                                        WasmStringSlice str) {
-  WasmStringSlice result;
-  result.start = wasm_strndup(allocator, str.start, str.length);
-  result.length = str.length;
-  return result;
-}
-
 /* TODO(binji): remove all this if-block stuff when we switch to postorder */
 static WasmResult push_depth(WasmReadAstContext* ctx) {
   uint32_t* depth = wasm_append_uint32(ctx->allocator, &ctx->depth_stack);
@@ -307,10 +299,10 @@ static WasmResult on_import(uint32_t index,
   WasmImport* import = &field->import;
   WASM_ZERO_MEMORY(*import);
   import->import_type = WASM_IMPORT_HAS_TYPE;
-  CHECK_ALLOC_NULL_STR(
-      ctx, import->module_name = dup_string_slice(ctx->allocator, module_name));
-  CHECK_ALLOC_NULL_STR(
-      ctx, import->func_name = dup_string_slice(ctx->allocator, function_name));
+  CHECK_ALLOC_NULL_STR(ctx, import->module_name = wasm_dup_string_slice(
+                                ctx->allocator, module_name));
+  CHECK_ALLOC_NULL_STR(ctx, import->func_name = wasm_dup_string_slice(
+                                ctx->allocator, function_name));
   import->type_var.type = WASM_VAR_TYPE_INDEX;
   assert(sig_index < ctx->module->func_types.size);
   import->type_var.index = sig_index;
@@ -1009,8 +1001,8 @@ static WasmResult on_export(uint32_t index,
 
   WasmExport* export = &field->export_;
   WASM_ZERO_MEMORY(*export);
-  CHECK_ALLOC_NULL_STR(ctx,
-                       export->name = dup_string_slice(ctx->allocator, name));
+  CHECK_ALLOC_NULL_STR(
+      ctx, export->name = wasm_dup_string_slice(ctx->allocator, name));
   export->var.type = WASM_VAR_TYPE_INDEX;
   assert(func_index < ctx->module->funcs.size);
   export->var.index = func_index;
@@ -1038,7 +1030,8 @@ static WasmResult on_function_name(uint32_t index,
   WasmReadAstContext* ctx = user_data;
 
   WasmStringSlice dup_name;
-  CHECK_ALLOC_NULL_STR(ctx, dup_name = dup_string_slice(ctx->allocator, name));
+  CHECK_ALLOC_NULL_STR(ctx,
+                       dup_name = wasm_dup_string_slice(ctx->allocator, name));
 
   WasmBinding* binding = wasm_insert_binding(
       ctx->allocator, &ctx->module->func_bindings, &dup_name);
@@ -1086,7 +1079,8 @@ static WasmResult on_local_name(uint32_t func_index,
   WasmFunc* func = module->funcs.data[func_index];
   uint32_t num_params = get_num_func_params(module, func);
   WasmStringSlice dup_name;
-  CHECK_ALLOC_NULL_STR(ctx, dup_name = dup_string_slice(ctx->allocator, name));
+  CHECK_ALLOC_NULL_STR(ctx,
+                       dup_name = wasm_dup_string_slice(ctx->allocator, name));
   WasmBinding* binding;
   if (local_index < num_params) {
     /* param name */
diff --git a/src/wasm-binary-reader-interpreter.c b/src/wasm-binary-reader-interpreter.c
new file mode 100644
index 00000000..d50e5751
--- /dev/null
+++ b/src/wasm-binary-reader-interpreter.c
@@ -0,0 +1,1537 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#include "wasm-binary-reader-interpreter.h"
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "wasm-allocator.h"
+#include "wasm-binary-reader.h"
+#include "wasm-interpreter.h"
+#include "wasm-writer.h"
+
+#define LOG 0
+
+#define INVALID_FUNC_INDEX ((uint32_t)~0)
+
+#define CHECK_ALLOC_(ctx, cond)                                           \
+  do {                                                                    \
+    if (!(cond)) {                                                        \
+      print_error((ctx), "%s:%d: allocation failed", __FILE__, __LINE__); \
+      return WASM_ERROR;                                                  \
+    }                                                                     \
+  } while (0)
+
+#define CHECK_ALLOC(ctx, e) CHECK_ALLOC_((ctx), (e) == WASM_OK)
+#define CHECK_ALLOC_NULL(ctx, v) CHECK_ALLOC_((ctx), (v))
+#define CHECK_ALLOC_NULL_STR(ctx, v) CHECK_ALLOC_((ctx), (v).start)
+
+#define CHECK_RESULT(expr) \
+  do {                     \
+    if ((expr) != WASM_OK) \
+      return WASM_ERROR;   \
+  } while (0)
+
+#define CHECK_DEPTH(ctx, depth)                                 \
+  do {                                                          \
+    if ((depth) >= (ctx)->depth_stack.size) {                   \
+      print_error((ctx), "invalid depth: %d (max %d)", (depth), \
+                  (int)((ctx)->depth_stack.size));              \
+      return WASM_ERROR;                                        \
+    }                                                           \
+  } while (0)
+
+#define CHECK_LOCAL(ctx, local_index)                                       \
+  do {                                                                      \
+    uint32_t max_local_index =                                              \
+        (ctx)->current_func->param_and_local_types.size;                    \
+    if ((local_index) >= max_local_index) {                                 \
+      print_error((ctx), "invalid local_index: %d (max %d)", (local_index), \
+                  max_local_index);                                         \
+      return WASM_ERROR;                                                    \
+    }                                                                       \
+  } while (0)
+
+#define WASM_TYPE_ANY WASM_NUM_TYPES
+
+static const char* s_type_names[] = {
+    "void", "i32", "i64", "f32", "f64", "any",
+};
+WASM_STATIC_ASSERT(WASM_ARRAY_SIZE(s_type_names) == WASM_NUM_TYPES + 1);
+
+/* TODO(binji): combine with the ones defined in wasm-check? */
+#define V(rtype, type1, type2, mem_size, code, NAME, text) \
+  [code] = WASM_TYPE_##rtype,
+static WasmType s_opcode_rtype[] = {WASM_FOREACH_OPCODE(V)};
+#undef V
+
+#define V(rtype, type1, type2, mem_size, code, NAME, text) \
+  [code] = WASM_TYPE_##type1,
+static WasmType s_opcode_type1[] = {WASM_FOREACH_OPCODE(V)};
+#undef V
+
+#define V(rtype, type1, type2, mem_size, code, NAME, text) \
+  [code] = WASM_TYPE_##type2,
+static WasmType s_opcode_type2[] = {WASM_FOREACH_OPCODE(V)};
+#undef V
+
+#if LOG
+#define V(rtype, type1, type2, mem_size, code, NAME, text) [code] = text,
+static const char* s_opcode_name[] = {
+  WASM_FOREACH_OPCODE(V)
+  [WASM_OPCODE_ALLOCA] = "alloca",
+  [WASM_OPCODE_DISCARD] = "discard",
+  [WASM_OPCODE_DISCARD_KEEP] = "discard_keep",
+};
+#undef V
+#endif
+
+WASM_DEFINE_VECTOR(uint32, WasmUint32);
+WASM_DEFINE_VECTOR(uint32_vector, WasmUint32Vector);
+
+typedef struct WasmDepthNode {
+  WasmType type;
+  /* we store the value stack size at this depth so we know how many
+   * values to discard if we break to this depth */
+  uint32_t value_stack_size;
+  uint32_t offset;
+} WasmDepthNode;
+WASM_DEFINE_VECTOR(depth_node, WasmDepthNode);
+
+typedef struct WasmInterpreterExpr {
+  WasmOpcode opcode;
+  WasmType type;
+  union {
+    /* clang-format off */
+    struct { uint32_t depth; } br, br_if;
+    struct { uint32_t value_stack_size; } block, loop;
+    struct { uint32_t num_targets, table_offset; } br_table;
+    struct { uint32_t func_index; } call;
+    struct { uint32_t import_index; } call_import;
+    struct { uint32_t sig_index; } call_indirect;
+    struct { uint32_t fixup_offset; } if_;
+    struct {
+      uint32_t fixup_cond_offset, fixup_true_offset, value_stack_size;
+    } if_else;
+    struct { uint32_t mem_offset, alignment_log2; } load, store;
+    struct { uint32_t local_index; } get_local, set_local;
+    /* clang-format on */
+  };
+} WasmInterpreterExpr;
+
+typedef struct WasmExprNode {
+  WasmInterpreterExpr expr;
+  uint32_t index;
+  uint32_t total;
+} WasmExprNode;
+WASM_DEFINE_VECTOR(expr_node, WasmExprNode);
+
+typedef struct WasmInterpreterFunc {
+  uint32_t sig_index;
+  uint32_t offset;
+  uint32_t local_decl_count;
+  uint32_t local_count;
+  WasmTypeVector param_and_local_types;
+} WasmInterpreterFunc;
+WASM_DEFINE_ARRAY(interpreter_func, WasmInterpreterFunc);
+
+typedef struct WasmReadInterpreterContext {
+  WasmAllocator* allocator;
+  WasmAllocator* memory_allocator;
+  WasmInterpreterModule* module;
+  WasmInterpreterFuncArray funcs;
+  WasmInterpreterFunc* current_func;
+  WasmExprNodeVector expr_stack;
+  WasmDepthNodeVector depth_stack;
+  WasmUint32VectorVector func_fixups;
+  WasmUint32VectorVector depth_fixups;
+  uint32_t value_stack_size;
+  uint32_t depth;
+  uint32_t start_func_index;
+  WasmMemoryWriter istream_writer;
+  uint32_t istream_offset;
+  /* the last expression evaluated at the top-level of a func */
+  WasmInterpreterExpr last_expr;
+  int last_expr_was_discarded;
+} WasmReadInterpreterContext;
+
+static WasmDepthNode* get_depth_node(WasmReadInterpreterContext* ctx,
+                                     uint32_t depth) {
+  assert(depth < ctx->depth_stack.size);
+  return &ctx->depth_stack.data[depth];
+}
+
+static uint32_t get_istream_offset(WasmReadInterpreterContext* ctx) {
+  return ctx->istream_offset;
+}
+
+static uint32_t get_result_count(WasmType result_type) {
+  return (result_type == WASM_TYPE_VOID || result_type == WASM_TYPE_ANY) ? 0
+                                                                         : 1;
+}
+
+static void on_error(uint32_t offset, const char* message, void* user_data);
+
+static void print_error(WasmReadInterpreterContext* ctx,
+                        const char* format,
+                        ...) {
+  va_list args;
+  va_list args_copy;
+  va_start(args, format);
+  va_copy(args_copy, args);
+
+  char buffer[128];
+  int len = wasm_vsnprintf(buffer, sizeof(buffer), format, args);
+  va_end(args);
+  if (len + 1 > sizeof(buffer)) {
+    char* buffer2 = alloca(len + 1);
+    len = wasm_vsnprintf(buffer2, len + 1, format, args_copy);
+    va_end(args_copy);
+  }
+
+  on_error(WASM_INVALID_OFFSET, buffer, ctx);
+}
+
+static void adjust_value_stack(WasmReadInterpreterContext* ctx,
+                               int32_t amount) {
+  uint32_t old_size = ctx->value_stack_size;
+  uint32_t new_size = old_size + (uint32_t)amount;
+  assert((amount <= 0 && new_size <= old_size) ||
+         (amount > 0 && new_size > old_size));
+  WASM_USE(old_size);
+  WASM_USE(new_size);
+  ctx->value_stack_size += (uint32_t)amount;
+#ifndef NDEBUG
+  if (ctx->depth_stack.size > 0) {
+    assert(ctx->value_stack_size >=
+           ctx->depth_stack.data[ctx->depth_stack.size - 1].value_stack_size);
+  } else {
+    assert(ctx->value_stack_size >=
+           ctx->current_func->param_and_local_types.size);
+  }
+#endif
+}
+
+static void reset_value_stack(WasmReadInterpreterContext* ctx,
+                              WasmInterpreterExpr* expr) {
+  ctx->value_stack_size =
+      expr->block.value_stack_size + get_result_count(expr->type);
+}
+
+static WasmResult type_mismatch(WasmReadInterpreterContext* ctx,
+                                WasmType expected_type,
+                                WasmType type,
+                                const char* desc) {
+  print_error(ctx, "type mismatch%s, expected %s but got %s.", desc,
+              s_type_names[expected_type], s_type_names[type]);
+  return WASM_ERROR;
+}
+
+static WasmResult check_type_exact(WasmReadInterpreterContext* ctx,
+                                   WasmType expected_type,
+                                   WasmType type,
+                                   const char* desc) {
+  if (expected_type == type)
+    return WASM_OK;
+  return type_mismatch(ctx, expected_type, type, desc);
+}
+
+static WasmResult check_type(WasmReadInterpreterContext* ctx,
+                             WasmType expected_type,
+                             WasmType type,
+                             const char* desc) {
+  if (expected_type == WASM_TYPE_ANY || type == WASM_TYPE_ANY ||
+      expected_type == WASM_TYPE_VOID) {
+    return WASM_OK;
+  }
+  return check_type_exact(ctx, expected_type, type, desc);
+}
+
+static void unify_type(WasmType* dest_type, WasmType type) {
+  if (*dest_type == WASM_TYPE_ANY)
+    *dest_type = type;
+  else if (type != WASM_TYPE_ANY && *dest_type != type)
+    *dest_type = WASM_TYPE_VOID;
+}
+
+static WasmResult unify_and_check_type(WasmReadInterpreterContext* ctx,
+                                       WasmType* dest_type,
+                                       WasmType type,
+                                       const char* desc) {
+  unify_type(dest_type, type);
+  return check_type(ctx, *dest_type, type, desc);
+}
+
+static WasmResult unify_and_check_type_exact(WasmReadInterpreterContext* ctx,
+                                             WasmType* dest_type,
+                                             WasmType type,
+                                             const char* desc) {
+  unify_type(dest_type, type);
+  return check_type_exact(ctx, *dest_type, type, desc);
+}
+
+static WasmResult emit_data_at(WasmReadInterpreterContext* ctx,
+                               size_t offset,
+                               const void* data,
+                               size_t size) {
+  return ctx->istream_writer.base.write_data(
+      offset, data, size, ctx->istream_writer.base.user_data);
+}
+
+static WasmResult emit_data(WasmReadInterpreterContext* ctx,
+                            const void* data,
+                            size_t size) {
+  CHECK_RESULT(emit_data_at(ctx, ctx->istream_offset, data, size));
+  ctx->istream_offset += size;
+  return WASM_OK;
+}
+
+static WasmResult emit_opcode(WasmReadInterpreterContext* ctx,
+                              WasmOpcode opcode,
+                              int32_t stack_adjustment) {
+  CHECK_RESULT(emit_data(ctx, &opcode, sizeof(uint8_t)));
+  adjust_value_stack(ctx, stack_adjustment);
+  return WASM_OK;
+}
+
+static WasmResult emit_i8(WasmReadInterpreterContext* ctx, uint8_t value) {
+  return emit_data(ctx, &value, sizeof(value));
+}
+
+static WasmResult emit_i32(WasmReadInterpreterContext* ctx, uint32_t value) {
+  return emit_data(ctx, &value, sizeof(value));
+}
+
+static WasmResult emit_i64(WasmReadInterpreterContext* ctx, uint64_t value) {
+  return emit_data(ctx, &value, sizeof(value));
+}
+
+static WasmResult emit_i32_at(WasmReadInterpreterContext* ctx,
+                              uint32_t offset,
+                              uint32_t value) {
+  return emit_data_at(ctx, offset, &value, sizeof(value));
+}
+
+static void unemit_discard(WasmReadInterpreterContext* ctx) {
+  assert(ctx->istream_offset > 0);
+  assert(ctx->istream_offset <= ctx->istream_writer.buf.size);
+  assert(((uint8_t*)ctx->istream_writer.buf.start)[ctx->istream_offset - 1] ==
+         WASM_OPCODE_DISCARD);
+  ctx->istream_offset--;
+}
+
+static WasmResult emit_discard(WasmReadInterpreterContext* ctx) {
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DISCARD, -1));
+  return WASM_OK;
+}
+
+static WasmResult maybe_emit_discard(WasmReadInterpreterContext* ctx,
+                                     WasmType type,
+                                     int* out_discarded) {
+  int should_discard = type != WASM_TYPE_VOID && type != WASM_TYPE_ANY;
+  if (out_discarded)
+    *out_discarded = should_discard;
+  if (should_discard)
+    return emit_discard(ctx);
+  return WASM_OK;
+}
+
+static WasmResult emit_discard_keep(WasmReadInterpreterContext* ctx,
+                                    uint32_t discard,
+                                    uint8_t keep) {
+  assert(discard != UINT32_MAX);
+  assert(keep <= 1);
+  if (discard > 0) {
+    if (discard == 1 && keep == 0) {
+      CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DISCARD, 0));
+    } else {
+      CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_DISCARD_KEEP, 0));
+      CHECK_RESULT(emit_i32(ctx, discard));
+      CHECK_RESULT(emit_i8(ctx, keep));
+    }
+  }
+  return WASM_OK;
+}
+
+static WasmResult emit_return(WasmReadInterpreterContext* ctx,
+                              WasmType result_type) {
+  uint32_t discard_count = ctx->value_stack_size;
+  uint32_t keep_count = get_result_count(result_type);
+  CHECK_RESULT(emit_discard_keep(ctx, discard_count, keep_count));
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_RETURN, 0));
+  return WASM_OK;
+}
+
+static WasmResult append_fixup(WasmReadInterpreterContext* ctx,
+                               WasmUint32VectorVector* fixups_vector,
+                               uint32_t index) {
+  if (index >= fixups_vector->size) {
+    CHECK_ALLOC(ctx, wasm_resize_uint32_vector_vector(
+                         ctx->allocator, fixups_vector, index + 1));
+  }
+  WasmUint32Vector* fixups = &fixups_vector->data[index];
+  uint32_t offset = get_istream_offset(ctx);
+  CHECK_ALLOC(ctx, wasm_append_uint32_value(ctx->allocator, fixups, &offset));
+  return WASM_OK;
+}
+
+static WasmResult emit_br_offset(WasmReadInterpreterContext* ctx,
+                                 uint32_t depth,
+                                 uint32_t offset) {
+  if (offset == WASM_INVALID_OFFSET)
+    CHECK_RESULT(append_fixup(ctx, &ctx->depth_fixups, depth));
+  CHECK_RESULT(emit_i32(ctx, offset));
+  return WASM_OK;
+}
+
+static WasmResult emit_br(WasmReadInterpreterContext* ctx,
+                          uint32_t depth,
+                          WasmDepthNode* node) {
+  WasmType expected_type = node->type;
+  assert(ctx->value_stack_size >= node->value_stack_size);
+  uint32_t discard_count = ctx->value_stack_size - node->value_stack_size;
+  uint8_t keep_count = get_result_count(expected_type);
+  CHECK_RESULT(emit_discard_keep(ctx, discard_count, keep_count));
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR, 0));
+  CHECK_RESULT(emit_br_offset(ctx, depth, node->offset));
+  return WASM_OK;
+}
+
+static WasmResult emit_br_table_offset(WasmReadInterpreterContext* ctx,
+                                       uint32_t depth,
+                                       WasmDepthNode* node,
+                                       uint32_t discard_count) {
+  discard_count = ctx->value_stack_size - node->value_stack_size;
+  CHECK_RESULT(emit_br_offset(ctx, depth, node->offset));
+  CHECK_RESULT(emit_i32(ctx, discard_count));
+  return WASM_OK;
+}
+
+static WasmResult emit_func_offset(WasmReadInterpreterContext* ctx,
+                                   WasmInterpreterFunc* func,
+                                   uint32_t func_index) {
+  if (func->offset == WASM_INVALID_OFFSET)
+    CHECK_RESULT(append_fixup(ctx, &ctx->func_fixups, func_index));
+  CHECK_RESULT(emit_i32(ctx, func->offset));
+  return WASM_OK;
+}
+
+static WasmInterpreterFunc* get_func(WasmReadInterpreterContext* ctx,
+                                     uint32_t func_index) {
+  assert(func_index < ctx->funcs.size);
+  return &ctx->funcs.data[func_index];
+}
+
+static WasmInterpreterImport* get_import(WasmReadInterpreterContext* ctx,
+                                         uint32_t import_index) {
+  assert(import_index < ctx->module->imports.size);
+  return &ctx->module->imports.data[import_index];
+}
+
+static WasmInterpreterFuncSignature* get_signature(
+    WasmReadInterpreterContext* ctx,
+    uint32_t sig_index) {
+  assert(sig_index < ctx->module->sigs.size);
+  return &ctx->module->sigs.data[sig_index];
+}
+
+static WasmInterpreterFuncSignature* get_func_signature(
+    WasmReadInterpreterContext* ctx,
+    WasmInterpreterFunc* func) {
+  return get_signature(ctx, func->sig_index);
+}
+
+static WasmType get_local_index_type(WasmInterpreterFunc* func,
+                                     uint32_t local_index) {
+  assert(local_index < func->param_and_local_types.size);
+  return func->param_and_local_types.data[local_index];
+}
+
+static WasmResult push_depth_with_offset(WasmReadInterpreterContext* ctx,
+                                         WasmType type,
+                                         uint32_t offset) {
+  WasmDepthNode* node =
+      wasm_append_depth_node(ctx->allocator, &ctx->depth_stack);
+  CHECK_ALLOC_NULL(ctx, node);
+  node->type = type;
+  node->value_stack_size = ctx->value_stack_size;
+  node->offset = offset;
+#if LOG
+  fprintf(stderr, "   (%d): push depth %" PRIzd ":%s\n", ctx->value_stack_size,
+          ctx->depth_stack.size - 1, s_type_names[type]);
+#endif
+  return WASM_OK;
+}
+
+static WasmResult push_depth(WasmReadInterpreterContext* ctx, WasmType type) {
+  return push_depth_with_offset(ctx, type, WASM_INVALID_OFFSET);
+}
+
+static void pop_depth(WasmReadInterpreterContext* ctx) {
+#if LOG
+  fprintf(stderr, "   (%d): pop depth %" PRIzd "\n", ctx->value_stack_size,
+          ctx->depth_stack.size - 1);
+#endif
+  assert(ctx->depth_stack.size > 0);
+  ctx->depth_stack.size--;
+  ctx->depth_fixups.size = ctx->depth_stack.size;
+}
+
+static uint32_t translate_depth(WasmReadInterpreterContext* ctx,
+                                uint32_t depth) {
+  assert(depth < ctx->depth_stack.size);
+  return ctx->depth_stack.size - 1 - depth;
+}
+
+static WasmResult fixup_top_depth(WasmReadInterpreterContext* ctx,
+                                  uint32_t offset) {
+  uint32_t top = ctx->depth_stack.size - 1;
+  if (top >= ctx->depth_fixups.size) {
+    /* nothing to fixup */
+    return WASM_OK;
+  }
+
+  WasmUint32Vector* fixups = &ctx->depth_fixups.data[top];
+  uint32_t i;
+  for (i = 0; i < fixups->size; ++i)
+    CHECK_RESULT(emit_i32_at(ctx, fixups->data[i], offset));
+  /* reduce the size to 0 in case this gets reused. Keep the allocations for
+   * later use */
+  fixups->size = 0;
+  return WASM_OK;
+}
+
+static uint32_t translate_local_index(WasmReadInterpreterContext* ctx,
+                                      uint32_t local_index) {
+  assert(local_index < ctx->value_stack_size);
+  return ctx->value_stack_size - local_index;
+}
+
+void on_error(uint32_t offset, const char* message, void* user_data) {
+  if (offset == WASM_INVALID_OFFSET)
+    fprintf(stderr, "error: %s\n", message);
+  else
+    fprintf(stderr, "error: @0x%08x: %s\n", offset, message);
+}
+
+static WasmResult on_memory_initial_size_pages(uint32_t pages,
+                                               void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterMemory* memory = &ctx->module->memory;
+  memory->allocator = ctx->memory_allocator;
+  memory->page_size = pages;
+  memory->byte_size = pages * WASM_PAGE_SIZE;
+  CHECK_ALLOC_NULL(
+      ctx, memory->data = wasm_alloc_zero(
+               ctx->memory_allocator, memory->byte_size, WASM_DEFAULT_ALIGN));
+  return WASM_OK;
+}
+
+static WasmResult on_data_segment(uint32_t index,
+                                  uint32_t address,
+                                  const void* src_data,
+                                  uint32_t size,
+                                  void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterMemory* memory = &ctx->module->memory;
+  uint8_t* dst_data = memory->data;
+  memcpy(&dst_data[address], src_data, size);
+  return WASM_OK;
+}
+
+static WasmResult on_signature_count(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_ALLOC(ctx, wasm_new_interpreter_func_signature_array(
+                       ctx->allocator, &ctx->module->sigs, count));
+  return WASM_OK;
+}
+
+static WasmResult on_signature(uint32_t index,
+                               WasmType result_type,
+                               uint32_t param_count,
+                               WasmType* param_types,
+                               void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterFuncSignature* sig = get_signature(ctx, index);
+  sig->result_type = result_type;
+
+  CHECK_ALLOC(
+      ctx, wasm_reserve_types(ctx->allocator, &sig->param_types, param_count));
+  sig->param_types.size = param_count;
+  memcpy(sig->param_types.data, param_types, param_count * sizeof(WasmType));
+  return WASM_OK;
+}
+
+static WasmResult on_import_count(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_ALLOC(ctx, wasm_new_interpreter_import_array(
+                       ctx->allocator, &ctx->module->imports, count));
+  return WASM_OK;
+}
+
+static WasmResult on_import(uint32_t index,
+                            uint32_t sig_index,
+                            WasmStringSlice module_name,
+                            WasmStringSlice function_name,
+                            void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterImport* import = &ctx->module->imports.data[index];
+  CHECK_ALLOC_NULL_STR(ctx, import->module_name = wasm_dup_string_slice(
+                                ctx->allocator, module_name));
+  CHECK_ALLOC_NULL_STR(ctx, import->func_name = wasm_dup_string_slice(
+                                ctx->allocator, function_name));
+  assert(sig_index < ctx->module->sigs.size);
+  import->sig_index = sig_index;
+  return WASM_OK;
+}
+
+static WasmResult on_function_signatures_count(uint32_t count,
+                                               void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_ALLOC(
+      ctx, wasm_new_interpreter_func_array(ctx->allocator, &ctx->funcs, count));
+  CHECK_ALLOC(ctx, wasm_resize_uint32_vector_vector(ctx->allocator,
+                                                    &ctx->func_fixups, count));
+  return WASM_OK;
+}
+
+static WasmResult on_function_signature(uint32_t index,
+                                        uint32_t sig_index,
+                                        void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  assert(sig_index < ctx->module->sigs.size);
+  WasmInterpreterFunc* func = get_func(ctx, index);
+  func->offset = WASM_INVALID_OFFSET;
+  func->sig_index = sig_index;
+  return WASM_OK;
+}
+
+static WasmResult on_function_bodies_count(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  assert(count == ctx->funcs.size);
+  WASM_USE(ctx);
+  return WASM_OK;
+}
+
+static WasmResult begin_function_body(uint32_t index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterFunc* func = get_func(ctx, index);
+  WasmInterpreterFuncSignature* sig = get_signature(ctx, func->sig_index);
+  ctx->current_func = func;
+  func->offset = get_istream_offset(ctx);
+
+  /* fixup function references */
+  uint32_t i;
+  WasmUint32Vector* fixups = &ctx->func_fixups.data[index];
+  for (i = 0; i < fixups->size; ++i)
+    CHECK_RESULT(emit_i32_at(ctx, fixups->data[i], func->offset));
+
+  /* append param types */
+  for (i = 0; i < sig->param_types.size; ++i) {
+    CHECK_RESULT(wasm_append_type_value(ctx->allocator,
+                                        &func->param_and_local_types,
+                                        &sig->param_types.data[i]));
+  }
+
+  ctx->value_stack_size = sig->param_types.size;
+  WASM_ZERO_MEMORY(ctx->last_expr);
+  return WASM_OK;
+}
+
+static WasmResult end_function_body(uint32_t index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  if (ctx->expr_stack.size != 0) {
+    print_error(ctx, "expression stack not empty on function exit! %d items",
+                (int)ctx->expr_stack.size);
+    return WASM_ERROR;
+  }
+  WasmInterpreterFunc* func = ctx->current_func;
+  WasmInterpreterFuncSignature* sig = get_signature(ctx, func->sig_index);
+  if (ctx->last_expr.opcode != WASM_OPCODE_RETURN) {
+    if (sig->result_type != WASM_TYPE_VOID) {
+      CHECK_RESULT(check_type(ctx, sig->result_type, ctx->last_expr.type,
+                              " in function result"));
+      if (ctx->last_expr_was_discarded)
+        unemit_discard(ctx);
+    }
+    CHECK_RESULT(emit_return(ctx, sig->result_type));
+  }
+  ctx->current_func = NULL;
+  ctx->value_stack_size = 0;
+  return WASM_OK;
+}
+
+static WasmResult end_function_bodies_section(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  if (ctx->start_func_index != INVALID_FUNC_INDEX) {
+    WasmInterpreterFunc* func = get_func(ctx, ctx->start_func_index);
+    assert(func->offset != WASM_INVALID_OFFSET);
+    ctx->module->start_func_offset = func->offset;
+  }
+  return WASM_OK;
+}
+
+static WasmResult on_local_decl_count(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  ctx->current_func->local_decl_count = count;
+  return WASM_OK;
+}
+
+static WasmResult on_local_decl(uint32_t decl_index,
+                                uint32_t count,
+                                WasmType type,
+                                void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterFunc* func = ctx->current_func;
+  func->local_count += count;
+
+  uint32_t i;
+  for (i = 0; i < count; ++i) {
+    CHECK_RESULT(wasm_append_type_value(ctx->allocator,
+                                        &func->param_and_local_types, &type));
+  }
+
+  if (decl_index == func->local_decl_count - 1) {
+    /* last local declaration, allocate space for all locals. */
+    CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_ALLOCA, func->local_count));
+    CHECK_RESULT(emit_i32(ctx, func->local_count));
+  }
+  return WASM_OK;
+}
+
+static WasmResult reduce(WasmReadInterpreterContext* ctx,
+                         WasmInterpreterExpr* expr) {
+  int done = 0;
+  while (!done) {
+    done = 1;
+
+    if (ctx->expr_stack.size == 0) {
+#if LOG
+      fprintf(stderr, "%3" PRIzd "(%d): reduce: <- %s:%s\n",
+              ctx->expr_stack.size, ctx->value_stack_size,
+              s_opcode_name[expr->opcode], s_type_names[expr->type]);
+#endif
+
+      /* discard all top-level values. The last one is the return value, which
+       * we don't want to discard, but we won't know if this is the last
+       * expression until we get the end_function_body message. So we'll always
+       * write in a discard here, then remove it later if necessary. */
+      CHECK_RESULT(
+          maybe_emit_discard(ctx, expr->type, &ctx->last_expr_was_discarded));
+      ctx->last_expr = *expr;
+    } else {
+      WasmExprNode* top = &ctx->expr_stack.data[ctx->expr_stack.size - 1];
+      assert(top->index < top->total);
+
+#if LOG
+      fprintf(stderr, "%3" PRIzd "(%d): reduce: %s(%d/%d) <- %s:%s\n",
+              ctx->expr_stack.size, ctx->value_stack_size,
+              s_opcode_name[top->expr.opcode], top->index, top->total,
+              s_opcode_name[expr->opcode], s_type_names[expr->type]);
+#endif
+#if LOG
+      if (top->expr.opcode == WASM_OPCODE_BR) {
+        fprintf(stderr, "      : br depth %u\n", top->expr.br.depth);
+      }
+#endif
+
+      uint32_t cur_index = top->index++;
+      int is_expr_done = top->index == top->total;
+
+      switch (top->expr.opcode) {
+        /* handles all unary and binary operators */
+        default:
+          if (is_expr_done) {
+            CHECK_RESULT(emit_opcode(ctx, top->expr.opcode, 1 - top->total));
+          } else {
+            WasmType expected_type;
+            if (cur_index == 0) {
+              expected_type = s_opcode_type1[top->expr.opcode];
+            } else if (cur_index == 1) {
+              expected_type = s_opcode_type2[top->expr.opcode];
+            } else {
+              assert(0);
+              break;
+            }
+            /* TODO use opcode name here */
+            CHECK_RESULT(check_type_exact(ctx, expected_type, expr->type, ""));
+          }
+          break;
+
+        case WASM_OPCODE_BLOCK:
+          if (is_expr_done)
+            unify_type(&top->expr.type, expr->type);
+          if (top->expr.type == WASM_TYPE_VOID || !is_expr_done)
+            CHECK_RESULT(maybe_emit_discard(ctx, expr->type, NULL));
+          if (is_expr_done) {
+            CHECK_RESULT(fixup_top_depth(ctx, get_istream_offset(ctx)));
+            pop_depth(ctx);
+            reset_value_stack(ctx, &top->expr);
+          }
+          break;
+
+        case WASM_OPCODE_BR: {
+          assert(cur_index == 0 && is_expr_done);
+          uint32_t depth = top->expr.br.depth;
+          WasmDepthNode* node = get_depth_node(ctx, depth);
+          CHECK_RESULT(unify_and_check_type_exact(ctx, &node->type, expr->type,
+                                                  " in br"));
+          CHECK_RESULT(emit_br(ctx, depth, node));
+          break;
+        }
+
+        case WASM_OPCODE_BR_IF: {
+          uint32_t depth = top->expr.br.depth;
+          WasmDepthNode* node = get_depth_node(ctx, depth);
+          if (cur_index == 0) {
+            CHECK_RESULT(unify_and_check_type_exact(ctx, &node->type,
+                                                    expr->type, " in br_if"));
+          } else {
+            assert(cur_index == 1 && is_expr_done);
+            CHECK_RESULT(
+                check_type_exact(ctx, WASM_TYPE_I32, expr->type, " in br_if"));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I32_EQZ, 0));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_IF, -1));
+            uint32_t fixup_br_offset = get_istream_offset(ctx);
+            CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET));
+            CHECK_RESULT(emit_br(ctx, depth, node));
+            CHECK_RESULT(emit_i32_at(ctx, fixup_br_offset,
+                                     get_istream_offset(ctx)));
+          }
+          break;
+        }
+
+        case WASM_OPCODE_BR_TABLE: {
+          assert(cur_index == 0 && is_expr_done);
+          CHECK_RESULT(
+              check_type_exact(ctx, WASM_TYPE_I32, expr->type, " in br_table"));
+          CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_TABLE, -1));
+          CHECK_RESULT(emit_i32(ctx, top->expr.br_table.num_targets));
+          CHECK_RESULT(emit_i32(ctx, top->expr.br_table.table_offset));
+          break;
+        }
+
+        case WASM_OPCODE_CALL_FUNCTION: {
+          WasmInterpreterFunc* func = get_func(ctx, top->expr.call.func_index);
+          WasmInterpreterFuncSignature* sig = get_func_signature(ctx, func);
+          CHECK_RESULT(check_type_exact(ctx, sig->param_types.data[cur_index],
+                                        expr->type, " in call"));
+          if (is_expr_done) {
+            int32_t num_results = get_result_count(sig->result_type);
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CALL_FUNCTION,
+                                     num_results - top->total));
+            CHECK_RESULT(
+                emit_func_offset(ctx, func, top->expr.call.func_index));
+          }
+          break;
+        }
+
+        case WASM_OPCODE_CALL_IMPORT: {
+          WasmInterpreterImport* import =
+              get_import(ctx, top->expr.call_import.import_index);
+          WasmInterpreterFuncSignature* sig =
+              get_signature(ctx, import->sig_index);
+          CHECK_RESULT(check_type_exact(ctx, sig->param_types.data[cur_index],
+                                        expr->type, " in call_import"));
+          if (is_expr_done) {
+            int32_t num_results = get_result_count(sig->result_type);
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CALL_IMPORT,
+                                     num_results - top->total));
+            CHECK_RESULT(emit_i32(ctx, top->expr.call_import.import_index));
+          }
+          break;
+        }
+
+        case WASM_OPCODE_CALL_INDIRECT: {
+          WasmInterpreterFuncSignature* sig =
+              get_signature(ctx, top->expr.call_indirect.sig_index);
+          if (cur_index == 0) {
+            CHECK_RESULT(check_type_exact(ctx, WASM_TYPE_I32, expr->type,
+                                    " in call_indirect"));
+          } else {
+            CHECK_RESULT(check_type_exact(ctx,
+                                          sig->param_types.data[cur_index - 1],
+                                          expr->type, " in call_indirect"));
+          }
+          if (is_expr_done) {
+            int32_t num_results = get_result_count(sig->result_type);
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_CALL_INDIRECT,
+                                     num_results - top->total));
+            CHECK_RESULT(emit_i32(ctx, top->expr.call_indirect.sig_index));
+            /* the callee cleans up the params for us, but we have to clean up
+             * the function table index */
+            CHECK_RESULT(emit_discard_keep(ctx, 1, num_results));
+          }
+          break;
+        }
+
+        case WASM_OPCODE_GROW_MEMORY:
+          assert(cur_index == 0 && is_expr_done);
+          CHECK_RESULT(check_type_exact(ctx, WASM_TYPE_I32, expr->type,
+                                        " in grow_memory"));
+          CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_GROW_MEMORY, 0));
+          break;
+
+        case WASM_OPCODE_IF:
+          if (cur_index == 0) {
+            /* after cond */
+            CHECK_RESULT(
+                check_type_exact(ctx, WASM_TYPE_I32, expr->type, " in if"));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I32_EQZ, 0));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_IF, -1));
+            top->expr.if_.fixup_offset = get_istream_offset(ctx);
+            CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET));
+          } else {
+            /* after true */
+            assert(cur_index == 1 && is_expr_done);
+            /* discard the last value, if there is one; if is always void */
+            CHECK_RESULT(maybe_emit_discard(ctx, expr->type, NULL));
+            CHECK_RESULT(emit_i32_at(ctx, top->expr.if_.fixup_offset,
+                                     get_istream_offset(ctx)));
+          }
+          break;
+
+        case WASM_OPCODE_IF_ELSE: {
+          if (cur_index == 0) {
+            /* after cond */
+            CHECK_RESULT(check_type_exact(ctx, WASM_TYPE_I32, expr->type,
+                                          " in if_else"));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I32_EQZ, 0));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR_IF, -1));
+            top->expr.if_else.fixup_cond_offset = get_istream_offset(ctx);
+            top->expr.if_else.value_stack_size = ctx->value_stack_size;
+            CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET));
+          } else {
+            CHECK_RESULT(unify_and_check_type(ctx, &top->expr.type, expr->type,
+                                              " in if_else"));
+            if (top->expr.type == WASM_TYPE_VOID)
+              CHECK_RESULT(maybe_emit_discard(ctx, expr->type, NULL));
+
+            if (cur_index == 1) {
+              /* after true */
+              CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR, 0));
+              top->expr.if_else.fixup_true_offset = get_istream_offset(ctx);
+              CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET));
+              CHECK_RESULT(emit_i32_at(ctx, top->expr.if_else.fixup_cond_offset,
+                                       get_istream_offset(ctx)));
+              /* reset the value stack for the other branch arm */
+              ctx->value_stack_size = top->expr.if_else.value_stack_size;
+            } else {
+              /* after false */
+              assert(cur_index == 2 && is_expr_done);
+              CHECK_RESULT(emit_i32_at(ctx, top->expr.if_else.fixup_true_offset,
+                                       get_istream_offset(ctx)));
+
+              /* weird case: if the true branch's type is not VOID or ANY, and
+               * the false branch's type is any, we need to adjust the stack up
+               * to match the other branch.
+               *
+               * A reduced expression's type is only ANY if it requires
+               * non-local control flow. In that case, we will not have
+               * adjusted the stack for that value, but the only normal control
+               * flow that will produce a value is from the true branch. */
+              if (top->expr.type != WASM_TYPE_VOID &&
+                  top->expr.type != WASM_TYPE_ANY &&
+                  expr->type == WASM_TYPE_ANY) {
+                adjust_value_stack(ctx, 1);
+              }
+            }
+          }
+          break;
+        }
+
+        case WASM_OPCODE_I32_LOAD8_S:
+        case WASM_OPCODE_I32_LOAD8_U:
+        case WASM_OPCODE_I32_LOAD16_S:
+        case WASM_OPCODE_I32_LOAD16_U:
+        case WASM_OPCODE_I64_LOAD8_S:
+        case WASM_OPCODE_I64_LOAD8_U:
+        case WASM_OPCODE_I64_LOAD16_S:
+        case WASM_OPCODE_I64_LOAD16_U:
+        case WASM_OPCODE_I64_LOAD32_S:
+        case WASM_OPCODE_I64_LOAD32_U:
+        case WASM_OPCODE_I32_LOAD:
+        case WASM_OPCODE_I64_LOAD:
+        case WASM_OPCODE_F32_LOAD:
+        case WASM_OPCODE_F64_LOAD:
+          assert(cur_index == 0 && is_expr_done);
+          /* TODO use opcode name here */
+          CHECK_RESULT(
+              check_type_exact(ctx, WASM_TYPE_I32, expr->type, " in load"));
+          CHECK_RESULT(emit_opcode(ctx, top->expr.opcode, 0));
+          CHECK_RESULT(emit_i32(ctx, top->expr.load.mem_offset));
+          break;
+
+        case WASM_OPCODE_LOOP: {
+          if (is_expr_done)
+            unify_type(&top->expr.type, expr->type);
+          if (top->expr.type == WASM_TYPE_VOID || !is_expr_done)
+            CHECK_RESULT(maybe_emit_discard(ctx, expr->type, NULL));
+          if (is_expr_done) {
+            pop_depth(ctx); /* continue */
+            CHECK_RESULT(fixup_top_depth(ctx, get_istream_offset(ctx)));
+            pop_depth(ctx); /* exit */
+            reset_value_stack(ctx, &top->expr);
+          }
+          break;
+        }
+
+        case WASM_OPCODE_RETURN: {
+          WasmInterpreterFuncSignature* sig =
+              get_func_signature(ctx, ctx->current_func);
+          CHECK_RESULT(check_type_exact(ctx, sig->result_type, expr->type,
+                                        " in return"));
+          CHECK_RESULT(emit_return(ctx, sig->result_type));
+          adjust_value_stack(ctx, -get_result_count(sig->result_type));
+          break;
+        }
+
+        case WASM_OPCODE_SELECT: {
+          if (is_expr_done) {
+            assert(cur_index == 2);
+            CHECK_RESULT(
+                check_type_exact(ctx, WASM_TYPE_I32, expr->type, " in select"));
+            CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_SELECT, -2));
+          } else {
+            assert(cur_index < 2);
+            CHECK_RESULT(unify_and_check_type_exact(ctx, &top->expr.type,
+                                                    expr->type, " in select"));
+          }
+          break;
+        }
+
+        case WASM_OPCODE_SET_LOCAL: {
+          assert(cur_index == 0 && is_expr_done);
+          CHECK_RESULT(check_type_exact(ctx, top->expr.type, expr->type,
+                                        " in set_local"));
+          CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_SET_LOCAL, 0));
+          uint32_t local_index =
+              translate_local_index(ctx, top->expr.set_local.local_index);
+          CHECK_RESULT(emit_i32(ctx, local_index));
+          break;
+        }
+
+        case WASM_OPCODE_I32_STORE8:
+        case WASM_OPCODE_I32_STORE16:
+        case WASM_OPCODE_I64_STORE8:
+        case WASM_OPCODE_I64_STORE16:
+        case WASM_OPCODE_I64_STORE32:
+        case WASM_OPCODE_I32_STORE:
+        case WASM_OPCODE_I64_STORE:
+        case WASM_OPCODE_F32_STORE:
+        case WASM_OPCODE_F64_STORE:
+          if (cur_index == 0) {
+            /* TODO use opcode name here */
+            CHECK_RESULT(
+                check_type_exact(ctx, WASM_TYPE_I32, expr->type, " in store"));
+          } else {
+            assert(cur_index == 1 && is_expr_done);
+            CHECK_RESULT(
+                check_type_exact(ctx, top->expr.type, expr->type, " in store"));
+            CHECK_RESULT(emit_opcode(ctx, top->expr.opcode, -1));
+            CHECK_RESULT(emit_i32(ctx, top->expr.store.mem_offset));
+          }
+          break;
+
+        case WASM_OPCODE_F32_CONST:
+        case WASM_OPCODE_F64_CONST:
+        case WASM_OPCODE_GET_LOCAL:
+        case WASM_OPCODE_I32_CONST:
+        case WASM_OPCODE_I64_CONST:
+        case WASM_OPCODE_MEMORY_SIZE:
+        case WASM_OPCODE_NOP:
+        case WASM_OPCODE_UNREACHABLE:
+          assert(0);
+          break;
+      }
+
+      if (is_expr_done) {
+        /* "recurse" and reduce the current expr */
+        expr = &top->expr;
+        ctx->expr_stack.size--;
+        done = 0;
+      }
+    }
+  }
+
+  return WASM_OK;
+}
+
+static WasmResult shift(WasmReadInterpreterContext* ctx,
+                        WasmInterpreterExpr* expr,
+                        uint32_t count) {
+  if (count > 0) {
+#if LOG
+    fprintf(stderr, "%3" PRIzd "(%d): shift: %s:%s %u\n", ctx->expr_stack.size,
+            ctx->value_stack_size, s_opcode_name[expr->opcode],
+            s_type_names[expr->type], count);
+#endif
+    WasmExprNode* node =
+        wasm_append_expr_node(ctx->allocator, &ctx->expr_stack);
+    CHECK_ALLOC_NULL(ctx, node);
+    node->expr = *expr;
+    node->index = 0;
+    node->total = count;
+    return WASM_OK;
+  } else {
+    adjust_value_stack(ctx, get_result_count(expr->type));
+    return reduce(ctx, expr);
+  }
+}
+
+static WasmResult on_unary_expr(WasmOpcode opcode, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = s_opcode_rtype[opcode];
+  expr.opcode = opcode;
+  return shift(ctx, &expr, 1);
+}
+
+static WasmResult on_binary_expr(WasmOpcode opcode, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = s_opcode_rtype[opcode];
+  expr.opcode = opcode;
+  return shift(ctx, &expr, 2);
+}
+
+static WasmResult on_block_expr(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = count ? WASM_TYPE_ANY : WASM_TYPE_VOID;
+  expr.opcode = WASM_OPCODE_BLOCK;
+  expr.block.value_stack_size = ctx->value_stack_size;
+  CHECK_RESULT(push_depth(ctx, expr.type));
+  return shift(ctx, &expr, count);
+}
+
+static WasmResult on_br_expr(uint32_t depth, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_DEPTH(ctx, depth);
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_ANY;
+  expr.opcode = WASM_OPCODE_BR;
+  expr.br.depth = translate_depth(ctx, depth);
+  return shift(ctx, &expr, 1);
+}
+
+static WasmResult on_br_if_expr(uint32_t depth, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_DEPTH(ctx, depth);
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_VOID;
+  expr.opcode = WASM_OPCODE_BR_IF;
+  expr.br.depth = translate_depth(ctx, depth);
+  return shift(ctx, &expr, 2);
+}
+
+static WasmResult on_br_table_expr(uint32_t num_targets,
+                                   uint32_t* target_depths,
+                                   uint32_t default_target_depth,
+                                   void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_ANY;
+  expr.opcode = WASM_OPCODE_BR_TABLE;
+  expr.br_table.num_targets = num_targets;
+
+  /* we need to parse the "key" expression before we can execute the br_table.
+   * Rather than store the target_depths in an Expr, we just write them out
+   * into the instruction stream and just jump over it. */
+  uint32_t fixup_br_offset = get_istream_offset(ctx);
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_BR, 0));
+  CHECK_RESULT(emit_i32(ctx, WASM_INVALID_OFFSET));
+
+  /* write the branch table as (offset, discard count) pairs */
+  expr.br_table.table_offset = get_istream_offset(ctx);
+
+  WasmDepthNode* node;
+  uint32_t discard_count;
+  uint32_t i;
+  for (i = 0; i < num_targets; ++i) {
+    uint32_t depth = translate_depth(ctx, target_depths[i]);
+    node = get_depth_node(ctx, depth);
+    discard_count = ctx->value_stack_size - node->value_stack_size;
+    CHECK_RESULT(unify_and_check_type_exact(ctx, &node->type, WASM_TYPE_VOID,
+                                            " in br_table"));
+    CHECK_RESULT(emit_br_table_offset(ctx, depth, node, discard_count));
+  }
+  /* write default target */
+  node = get_depth_node(ctx, translate_depth(ctx, default_target_depth));
+  discard_count = ctx->value_stack_size - node->value_stack_size;
+  CHECK_RESULT(unify_and_check_type_exact(ctx, &node->type, WASM_TYPE_VOID,
+                                          " in br_table"));
+  CHECK_RESULT(
+      emit_br_table_offset(ctx, default_target_depth, node, discard_count));
+
+  CHECK_RESULT(emit_i32_at(ctx, fixup_br_offset, get_istream_offset(ctx)));
+  return shift(ctx, &expr, 1);
+}
+
+static WasmResult on_call_expr(uint32_t func_index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  assert(func_index < ctx->funcs.size);
+  WasmInterpreterFunc* func = get_func(ctx, func_index);
+  WasmInterpreterFuncSignature* sig = get_func_signature(ctx, func);
+  WasmInterpreterExpr expr;
+  expr.type = sig->result_type;
+  expr.opcode = WASM_OPCODE_CALL_FUNCTION;
+  expr.call.func_index = func_index;
+  return shift(ctx, &expr, sig->param_types.size);
+}
+
+static WasmResult on_call_import_expr(uint32_t import_index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  assert(import_index < ctx->module->imports.size);
+  WasmInterpreterImport* import = get_import(ctx, import_index);
+  WasmInterpreterFuncSignature* sig = get_signature(ctx, import->sig_index);
+  WasmInterpreterExpr expr;
+  expr.type = sig->result_type;
+  expr.opcode = WASM_OPCODE_CALL_IMPORT;
+  expr.call_import.import_index = import_index;
+  return shift(ctx, &expr, sig->param_types.size);
+}
+
+static WasmResult on_call_indirect_expr(uint32_t sig_index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterFuncSignature* sig = get_signature(ctx, sig_index);
+  WasmInterpreterExpr expr;
+  expr.type = sig->result_type;
+  expr.opcode = WASM_OPCODE_CALL_INDIRECT;
+  expr.call_indirect.sig_index = sig_index;
+  return shift(ctx, &expr, sig->param_types.size + 1);
+}
+
+static WasmResult on_i32_const_expr(uint32_t value, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_I32;
+  expr.opcode = WASM_OPCODE_I32_CONST;
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I32_CONST, 1));
+  CHECK_RESULT(emit_i32(ctx, value));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_i64_const_expr(uint64_t value, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_I64;
+  expr.opcode = WASM_OPCODE_I64_CONST;
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_I64_CONST, 1));
+  CHECK_RESULT(emit_i64(ctx, value));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_f32_const_expr(uint32_t value_bits, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_F32;
+  expr.opcode = WASM_OPCODE_F32_CONST;
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_F32_CONST, 1));
+  CHECK_RESULT(emit_i32(ctx, value_bits));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_f64_const_expr(uint64_t value_bits, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_F64;
+  expr.opcode = WASM_OPCODE_F64_CONST;
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_F64_CONST, 1));
+  CHECK_RESULT(emit_i64(ctx, value_bits));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_get_local_expr(uint32_t local_index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = get_local_index_type(ctx->current_func, local_index);
+  expr.opcode = WASM_OPCODE_GET_LOCAL;
+  expr.get_local.local_index = translate_local_index(ctx, local_index);
+  CHECK_LOCAL(ctx, local_index);
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_GET_LOCAL, 1));
+  CHECK_RESULT(emit_i32(ctx, expr.get_local.local_index));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_grow_memory_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_I32;
+  expr.opcode = WASM_OPCODE_GROW_MEMORY;
+  return shift(ctx, &expr, 1);
+}
+
+static WasmResult on_if_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_VOID;
+  expr.opcode = WASM_OPCODE_IF;
+  return shift(ctx, &expr, 2);
+}
+
+static WasmResult on_if_else_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_ANY;
+  expr.opcode = WASM_OPCODE_IF_ELSE;
+  return shift(ctx, &expr, 3);
+}
+
+static WasmResult on_load_expr(WasmOpcode opcode,
+                               uint32_t alignment_log2,
+                               uint32_t offset,
+                               void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = s_opcode_rtype[opcode];
+  expr.opcode = opcode;
+  expr.load.mem_offset = offset;
+  expr.load.alignment_log2 = alignment_log2;
+  return shift(ctx, &expr, 1);
+}
+
+static WasmResult on_loop_expr(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = count ? WASM_TYPE_ANY : WASM_TYPE_VOID;
+  expr.opcode = WASM_OPCODE_LOOP;
+  expr.loop.value_stack_size = ctx->value_stack_size;
+  CHECK_RESULT(push_depth(ctx, expr.type)); /* exit */
+  CHECK_RESULT(push_depth_with_offset(ctx, WASM_TYPE_VOID,
+                                      get_istream_offset(ctx))); /* continue */
+  return shift(ctx, &expr, count);
+}
+
+static WasmResult on_memory_size_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_I32;
+  expr.opcode = WASM_OPCODE_MEMORY_SIZE;
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_MEMORY_SIZE, 0));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_nop_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_VOID;
+  expr.opcode = WASM_OPCODE_NOP;
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_return_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterFuncSignature* sig =
+      get_func_signature(ctx, ctx->current_func);
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_ANY;
+  expr.opcode = WASM_OPCODE_RETURN;
+  return shift(ctx, &expr, get_result_count(sig->result_type));
+}
+
+static WasmResult on_select_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_ANY;
+  expr.opcode = WASM_OPCODE_SELECT;
+  return shift(ctx, &expr, 3);
+}
+
+static WasmResult on_set_local_expr(uint32_t local_index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = get_local_index_type(ctx->current_func, local_index);
+  expr.opcode = WASM_OPCODE_SET_LOCAL;
+  expr.set_local.local_index = local_index;
+  CHECK_LOCAL(ctx, local_index);
+  return shift(ctx, &expr, 1);
+}
+
+static WasmResult on_store_expr(WasmOpcode opcode,
+                                uint32_t alignment_log2,
+                                uint32_t offset,
+                                void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = s_opcode_rtype[opcode];
+  expr.opcode = opcode;
+  expr.store.mem_offset = offset;
+  expr.store.alignment_log2 = alignment_log2;
+  return shift(ctx, &expr, 2);
+}
+
+static WasmResult on_unreachable_expr(void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExpr expr;
+  expr.type = WASM_TYPE_ANY;
+  expr.opcode = WASM_OPCODE_UNREACHABLE;
+  CHECK_RESULT(emit_opcode(ctx, WASM_OPCODE_UNREACHABLE, 0));
+  return reduce(ctx, &expr);
+}
+
+static WasmResult on_function_table_count(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_ALLOC(ctx, wasm_new_interpreter_func_table_entry_array(
+                       ctx->allocator, &ctx->module->func_table, count));
+  return WASM_OK;
+}
+
+static WasmResult on_function_table_entry(uint32_t index,
+                                          uint32_t func_index,
+                                          void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  assert(index < ctx->module->func_table.size);
+  WasmInterpreterFuncTableEntry* entry = &ctx->module->func_table.data[index];
+  WasmInterpreterFunc* func = get_func(ctx, func_index);
+  entry->sig_index = func->sig_index;
+  assert(func->offset != WASM_INVALID_OFFSET);
+  entry->func_offset = func->offset;
+  return WASM_OK;
+}
+
+static WasmResult on_start_function(uint32_t func_index, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  /* can't get the function offset yet, because we haven't parsed the
+   * functions. Just store the function index and resolve it later in
+   * end_function_bodies_section. */
+  assert(func_index < ctx->funcs.size);
+  ctx->start_func_index = func_index;
+  return WASM_OK;
+}
+
+static WasmResult on_export_count(uint32_t count, void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  CHECK_ALLOC(ctx, wasm_new_interpreter_export_array(
+                       ctx->allocator, &ctx->module->exports, count));
+  return WASM_OK;
+}
+
+static WasmResult on_export(uint32_t index,
+                            uint32_t func_index,
+                            WasmStringSlice name,
+                            void* user_data) {
+  WasmReadInterpreterContext* ctx = user_data;
+  WasmInterpreterExport* export = &ctx->module->exports.data[index];
+  WasmInterpreterFunc* func = get_func(ctx, func_index);
+  CHECK_ALLOC_NULL_STR(
+      ctx, export->name = wasm_dup_string_slice(ctx->allocator, name));
+  export->sig_index = func->sig_index;
+  export->func_offset = func->offset;
+  return WASM_OK;
+}
+
+static WasmBinaryReader s_binary_reader = {
+    .user_data = NULL,
+    .on_error = &on_error,
+
+    .on_memory_initial_size_pages = &on_memory_initial_size_pages,
+
+    .on_data_segment = &on_data_segment,
+
+    .on_signature_count = &on_signature_count,
+    .on_signature = &on_signature,
+
+    .on_import_count = &on_import_count,
+    .on_import = &on_import,
+
+    .on_function_signatures_count = &on_function_signatures_count,
+    .on_function_signature = &on_function_signature,
+
+    .on_function_bodies_count = &on_function_bodies_count,
+    .begin_function_body = &begin_function_body,
+    .on_local_decl_count = &on_local_decl_count,
+    .on_local_decl = &on_local_decl,
+    .on_binary_expr = &on_binary_expr,
+    .on_block_expr = &on_block_expr,
+    .on_br_expr = &on_br_expr,
+    .on_br_if_expr = &on_br_if_expr,
+    .on_br_table_expr = &on_br_table_expr,
+    .on_call_expr = &on_call_expr,
+    .on_call_import_expr = &on_call_import_expr,
+    .on_call_indirect_expr = &on_call_indirect_expr,
+    .on_compare_expr = &on_binary_expr,
+    .on_i32_const_expr = &on_i32_const_expr,
+    .on_i64_const_expr = &on_i64_const_expr,
+    .on_f32_const_expr = &on_f32_const_expr,
+    .on_f64_const_expr = &on_f64_const_expr,
+    .on_convert_expr = &on_unary_expr,
+    .on_get_local_expr = &on_get_local_expr,
+    .on_grow_memory_expr = &on_grow_memory_expr,
+    .on_if_expr = &on_if_expr,
+    .on_if_else_expr = &on_if_else_expr,
+    .on_load_expr = &on_load_expr,
+    .on_loop_expr = &on_loop_expr,
+    .on_memory_size_expr = &on_memory_size_expr,
+    .on_nop_expr = &on_nop_expr,
+    .on_return_expr = &on_return_expr,
+    .on_select_expr = &on_select_expr,
+    .on_set_local_expr = &on_set_local_expr,
+    .on_store_expr = &on_store_expr,
+    .on_unary_expr = &on_unary_expr,
+    .on_unreachable_expr = &on_unreachable_expr,
+    .end_function_body = &end_function_body,
+    .end_function_bodies_section = &end_function_bodies_section,
+
+    .on_function_table_count = &on_function_table_count,
+    .on_function_table_entry = &on_function_table_entry,
+
+    .on_start_function = &on_start_function,
+
+    .on_export_count = &on_export_count,
+    .on_export = &on_export,
+};
+
+static void destroy_context(WasmReadInterpreterContext* ctx) {
+  wasm_destroy_expr_node_vector(ctx->allocator, &ctx->expr_stack);
+  wasm_destroy_depth_node_vector(ctx->allocator, &ctx->depth_stack);
+  WASM_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->depth_fixups,
+                                   uint32_vector);
+  WASM_DESTROY_VECTOR_AND_ELEMENTS(ctx->allocator, ctx->func_fixups,
+                                   uint32_vector);
+}
+
+WasmResult wasm_read_binary_interpreter(
+    struct WasmAllocator* allocator,
+    struct WasmAllocator* memory_allocator,
+    const void* data,
+    size_t size,
+    struct WasmReadBinaryOptions* options,
+    struct WasmInterpreterModule* out_module) {
+  WasmReadInterpreterContext ctx;
+  WASM_ZERO_MEMORY(ctx);
+  ctx.allocator = allocator;
+  ctx.memory_allocator = memory_allocator;
+  ctx.module = out_module;
+  ctx.start_func_index = INVALID_FUNC_INDEX;
+  CHECK_RESULT(wasm_init_mem_writer(allocator, &ctx.istream_writer));
+
+  WasmBinaryReader reader;
+  WASM_ZERO_MEMORY(reader);
+  reader = s_binary_reader;
+  reader.user_data = &ctx;
+
+  WasmResult result = wasm_read_binary(allocator, data, size, &reader, options);
+  if (result == WASM_OK) {
+    wasm_steal_mem_writer_output_buffer(&ctx.istream_writer,
+                                        &out_module->istream);
+    out_module->istream.size = ctx.istream_offset;
+  }
+  destroy_context(&ctx);
+  return result;
+}
diff --git a/src/wasm-binary-reader-interpreter.h b/src/wasm-binary-reader-interpreter.h
new file mode 100644
index 00000000..6ac24374
--- /dev/null
+++ b/src/wasm-binary-reader-interpreter.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef WASM_BINARY_READER_INTERPRETER_H_
+#define WASM_BINARY_READER_INTERPRETER_H_
+
+#include "wasm-common.h"
+
+struct WasmAllocator;
+struct WasmInterpreterModule;
+struct WasmReadBinaryOptions;
+
+WASM_EXTERN_C_BEGIN
+WasmResult wasm_read_binary_interpreter(
+    struct WasmAllocator* allocator,
+    struct WasmAllocator* memory_allocator,
+    const void* data,
+    size_t size,
+    struct WasmReadBinaryOptions* options,
+    struct WasmInterpreterModule* out_module);
+WASM_EXTERN_C_END
+
+#endif /* WASM_BINARY_READER_INTERPRETER_H_ */
diff --git a/src/wasm-common.h b/src/wasm-common.h
index 4c1c87ea..f7221446 100644
--- a/src/wasm-common.h
+++ b/src/wasm-common.h
@@ -35,6 +35,7 @@
 #define WASM_FATAL(...) fprintf(stderr, __VA_ARGS__), exit(1)
 #define WASM_ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 #define WASM_ZERO_MEMORY(var) memset((void*)&(var), 0, sizeof(var))
+#define WASM_USE(x) (void)x
 
 #define WASM_PAGE_SIZE 0x10000 /* 64k */
 
@@ -258,6 +259,7 @@ typedef enum WasmOpcode {
   WASM_OPCODE_##NAME = code,
   WASM_FOREACH_OPCODE(V)
 #undef V
+  WASM_LAST_OPCODE
 } WasmOpcode;
 
 typedef enum WasmLiteralType {
diff --git a/src/wasm-config.h.in b/src/wasm-config.h.in
index 3fb68d7d..d9d7882a 100644
--- a/src/wasm-config.h.in
+++ b/src/wasm-config.h.in
@@ -61,18 +61,26 @@
 
 #if SIZEOF_INT == 4
 #define wasm_clz_u32(x) __builtin_clz(x)
+#define wasm_ctz_u32(x) __builtin_ctz(x)
+#define wasm_popcount_u32(x) __builtin_popcount(x)
 #elif SIZEOF_LONG == 4
 #define wasm_clz_u32(x) __builtin_clzl(x)
+#define wasm_ctz_u32(x) __builtin_ctzl(x)
+#define wasm_popcount_u32(x) __builtin_popcountl(x)
 #else
-#error "don't know how to define wasm_clz_u32"
+#error "don't know how to define 32-bit builtins"
 #endif
 
 #if SIZEOF_LONG == 8
 #define wasm_clz_u64(x) __builtin_clzl(x)
+#define wasm_ctz_u64(x) __builtin_ctzl(x)
+#define wasm_popcount_u64(x) __builtin_popcountl(x)
 #elif SIZEOF_LONG_LONG == 8
 #define wasm_clz_u64(x) __builtin_clzll(x)
+#define wasm_ctz_u64(x) __builtin_ctzll(x)
+#define wasm_popcount_u64(x) __builtin_popcountll(x)
 #else
-#error "don't know how to define wasm_clz_u64"
+#error "don't know how to define 64-bit builtins"
 #endif
 
 /* print format specifier for size_t */
@@ -115,6 +123,34 @@ __inline unsigned long wasm_clz_u64(unsigned __int64 mask) {
 #endif
 }
 
+__inline unsigned long wasm_ctz_u32(unsigned long mask) {
+  unsigned long index;
+  _BitScanForward(&index, mask);
+  return sizeof(unsigned long) * 8 - (index + 1);
+}
+
+__inline unsigned long wasm_ctz_u64(unsigned __int64 mask) {
+#if _M_X64
+  unsigned long index;
+  _BitScanForward64(&index, mask);
+  return sizeof(unsigned __int64) * 8 - (index + 1);
+#elif _M_IX86
+  /* TODO(binji): implement */
+#else
+#error unexpected architecture
+#endif
+}
+
+
+#define wasm_popcount_u32 __popcnt
+#if _M_X64
+#define wasm_popcount_u64 __popcnt64
+#elif _M_IX86
+/* TODO(binji): implement */
+#else
+#error unexpected architecture
+#endif
+
 /* print format specifier for size_t */
 #if SIZEOF_SIZE_T == 4
 #define PRIzd "d"
diff --git a/src/wasm-interp.c b/src/wasm-interp.c
new file mode 100644
index 00000000..ee41dfe8
--- /dev/null
+++ b/src/wasm-interp.c
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "wasm-allocator.h"
+#include "wasm-binary-reader.h"
+#include "wasm-binary-reader-interpreter.h"
+#include "wasm-interpreter.h"
+#include "wasm-option-parser.h"
+#include "wasm-stack-allocator.h"
+
+#define V(name, str) str,
+static const char* s_trap_strings[] = {FOREACH_INTERPRETER_RESULT(V)};
+#undef V
+
+static int s_verbose;
+static const char* s_infile;
+static const char* s_outfile;
+static WasmReadBinaryOptions s_read_binary_options =
+    WASM_READ_BINARY_OPTIONS_DEFAULT;
+static int s_use_libc_allocator;
+
+#define NOPE WASM_OPTION_NO_ARGUMENT
+#define YEP WASM_OPTION_HAS_ARGUMENT
+
+enum {
+  FLAG_VERBOSE,
+  FLAG_HELP,
+  FLAG_OUTPUT,
+  FLAG_USE_LIBC_ALLOCATOR,
+  NUM_FLAGS
+};
+
+static WasmOption s_options[] = {
+    {FLAG_VERBOSE, 'v', "verbose", NULL, NOPE,
+     "use multiple times for more info"},
+    {FLAG_HELP, 'h', "help", NULL, NOPE, "print this help message"},
+    {FLAG_OUTPUT, 'o', "output", "FILENAME", YEP,
+     "output file for the generated wast file"},
+    {FLAG_USE_LIBC_ALLOCATOR, 0, "use-libc-allocator", NULL, NOPE,
+     "use malloc, free, etc. instead of stack allocator"},
+};
+WASM_STATIC_ASSERT(NUM_FLAGS == WASM_ARRAY_SIZE(s_options));
+
+static void on_option(struct WasmOptionParser* parser,
+                      struct WasmOption* option,
+                      const char* argument) {
+  switch (option->id) {
+    case FLAG_VERBOSE:
+      s_verbose++;
+      break;
+
+    case FLAG_HELP:
+      wasm_print_help(parser);
+      exit(0);
+      break;
+
+    case FLAG_OUTPUT:
+      s_outfile = argument;
+      break;
+
+    case FLAG_USE_LIBC_ALLOCATOR:
+      s_use_libc_allocator = 1;
+      break;
+  }
+}
+
+static void on_argument(struct WasmOptionParser* parser, const char* argument) {
+  s_infile = argument;
+}
+
+static void on_option_error(struct WasmOptionParser* parser,
+                            const char* message) {
+  WASM_FATAL("%s\n", message);
+}
+
+static void parse_options(int argc, char** argv) {
+  WasmOptionParser parser;
+  WASM_ZERO_MEMORY(parser);
+  parser.options = s_options;
+  parser.num_options = WASM_ARRAY_SIZE(s_options);
+  parser.on_option = on_option;
+  parser.on_argument = on_argument;
+  parser.on_error = on_option_error;
+  wasm_parse_options(&parser, argc, argv);
+
+  if (!s_infile) {
+    wasm_print_help(&parser);
+    WASM_FATAL("No filename given.\n");
+  }
+}
+
+static void read_file(const char* filename,
+                      const void** out_data,
+                      size_t* out_size) {
+  FILE* infile = fopen(s_infile, "rb");
+  if (!infile)
+    WASM_FATAL("unable to read %s\n", s_infile);
+
+  if (fseek(infile, 0, SEEK_END) < 0)
+    WASM_FATAL("fseek to end failed.\n");
+
+  long size = ftell(infile);
+  if (size < 0)
+    WASM_FATAL("ftell failed.\n");
+
+  if (fseek(infile, 0, SEEK_SET) < 0)
+    WASM_FATAL("fseek to beginning failed.\n");
+
+  void* data = malloc(size);
+  if (fread(data, size, 1, infile) != 1)
+    WASM_FATAL("fread failed.\n");
+
+  *out_data = data;
+  *out_size = size;
+  fclose(infile);
+}
+
+static void print_typed_value(WasmInterpreterTypedValue* tv) {
+  switch (tv->type) {
+    case WASM_TYPE_I32:
+      printf("i32:%u", tv->value.i32);
+      break;
+
+    case WASM_TYPE_I64:
+      printf("i64:%" PRIu64, tv->value.i64);
+      break;
+
+    case WASM_TYPE_F32: {
+      float value;
+      memcpy(&value, &tv->value.f32_bits, sizeof(float));
+      printf("f32:%f", value);
+      break;
+    }
+
+    case WASM_TYPE_F64: {
+      double value;
+      memcpy(&value, &tv->value.f64_bits, sizeof(double));
+      printf("f64:%f", value);
+      break;
+    }
+
+    default:
+      assert(0);
+      break;
+  }
+}
+
+static WasmInterpreterTypedValue default_import_callback(
+    WasmInterpreterModule* module,
+    WasmInterpreterImport* import,
+    uint32_t num_args,
+    WasmInterpreterTypedValue* args,
+    void* user_data) {
+  printf("called import %.*s.%.*s(", (int)import->module_name.length,
+         import->module_name.start, (int)import->func_name.length,
+         import->func_name.start);
+  uint32_t i;
+  for (i = 0; i < num_args; ++i) {
+    print_typed_value(&args[i]);
+    if (i != num_args - 1)
+      printf(", ");
+  }
+
+  assert(import->sig_index < module->sigs.size);
+  WasmInterpreterFuncSignature* sig = &module->sigs.data[import->sig_index];
+
+  WasmInterpreterTypedValue result;
+  WASM_ZERO_MEMORY(result);
+  result.type = sig->result_type;
+
+  if (sig->result_type != WASM_TYPE_VOID) {
+    printf(") => ");
+    print_typed_value(&result);
+    printf("\n");
+  } else {
+    printf(")\n");
+  }
+  return result;
+}
+
+static void set_all_import_callbacks_to_default(WasmInterpreterModule* module) {
+  uint32_t i;
+  for (i = 0; i < module->imports.size; ++i) {
+    WasmInterpreterImport* import = &module->imports.data[i];
+    import->callback = default_import_callback;
+    import->user_data = NULL;
+  }
+}
+
+int main(int argc, char** argv) {
+  WasmStackAllocator stack_allocator;
+  WasmAllocator* allocator;
+  WasmAllocator* memory_allocator;
+
+  parse_options(argc, argv);
+
+  if (s_use_libc_allocator) {
+    allocator = &g_wasm_libc_allocator;
+  } else {
+    wasm_init_stack_allocator(&stack_allocator, &g_wasm_libc_allocator);
+    allocator = &stack_allocator.allocator;
+  }
+  memory_allocator = &g_wasm_libc_allocator;
+
+  const void* data;
+  size_t size;
+  read_file(s_infile, &data, &size);
+
+  WasmInterpreterModule module;
+  WasmResult result = wasm_read_binary_interpreter(
+      allocator, memory_allocator, data, size, &s_read_binary_options, &module);
+
+  if (result == WASM_OK) {
+    if (module.start_func_offset != WASM_INVALID_OFFSET) {
+      set_all_import_callbacks_to_default(&module);
+
+      WasmInterpreterThreadOptions thread_options;
+      WASM_ZERO_MEMORY(thread_options);
+      thread_options.value_stack_size = 1 * 1024 * 1024;
+      thread_options.call_stack_size = 64 * 1024;
+      thread_options.pc = module.start_func_offset;
+
+      WasmInterpreterThread thread;
+      result = wasm_init_interpreter_thread(allocator, &module, &thread,
+                                            &thread_options);
+      if (result == WASM_OK) {
+        int instruction_quantum = 1000;
+
+        WasmInterpreterResult iresult = WASM_INTERPRETER_OK;
+        while (iresult == WASM_INTERPRETER_OK) {
+          iresult = wasm_run_interpreter(&module, &thread, instruction_quantum);
+        }
+
+        if (iresult != WASM_INTERPRETER_RETURNED) {
+          /* trap */
+          fprintf(stderr, "error: %s\n", s_trap_strings[iresult]);
+          result = WASM_ERROR;
+        }
+        wasm_destroy_interpreter_thread(allocator, &thread);
+      }
+    } else {
+      fprintf(stderr, "no start function defined.\n");
+      result = WASM_ERROR;
+    }
+  }
+
+  if (!s_use_libc_allocator)
+    wasm_destroy_stack_allocator(&stack_allocator);
+  free((void*)data);
+  return result;
+}
diff --git a/src/wasm-interpreter.c b/src/wasm-interpreter.c
new file mode 100644
index 00000000..fbcf4511
--- /dev/null
+++ b/src/wasm-interpreter.c
@@ -0,0 +1,2118 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#include "wasm-interpreter.h"
+
+#include <assert.h>
+#include <math.h>
+
+#define LOG 0
+
+#if LOG
+#define V(rtype, type1, type2, mem_size, code, NAME, text) [code] = text,
+static const char* s_opcode_name[] = {
+  WASM_FOREACH_OPCODE(V)
+  [WASM_OPCODE_ALLOCA] = "alloca",
+  [WASM_OPCODE_DISCARD] = "discard",
+  [WASM_OPCODE_DISCARD_KEEP] = "discard_keep",
+};
+#undef V
+#endif
+
+#define CHECK_RESULT(expr) \
+  do {                     \
+    if ((expr) != WASM_OK) \
+      return WASM_ERROR;   \
+  } while (0)
+
+WasmResult wasm_init_interpreter_thread(WasmAllocator* allocator,
+                                        WasmInterpreterModule* module,
+                                        WasmInterpreterThread* thread,
+                                        WasmInterpreterThreadOptions* options) {
+  CHECK_RESULT(wasm_new_interpreter_value_array(allocator, &thread->value_stack,
+                                                options->value_stack_size));
+  CHECK_RESULT(wasm_new_uint32_array(allocator, &thread->call_stack,
+                                     options->call_stack_size));
+  thread->value_stack_top = 0;
+  thread->call_stack_top = 0;
+  thread->pc = options->pc;
+
+  /* allocate import_args based on the signature with the most params */
+  /* TODO(binji): move this elsewhere? */
+  uint32_t i;
+  uint32_t max_import_params = 0;
+  for (i = 0; i < module->imports.size; ++i) {
+    WasmInterpreterImport* import = &module->imports.data[i];
+    assert(import->sig_index < module->sigs.size);
+    WasmInterpreterFuncSignature* sig = &module->sigs.data[import->sig_index];
+    if (sig->param_types.size > max_import_params)
+      max_import_params = sig->param_types.size;
+  }
+  CHECK_RESULT(wasm_new_interpreter_typed_value_array(
+      allocator, &thread->import_args, max_import_params));
+  return WASM_OK;
+}
+
+void wasm_destroy_interpreter_thread(WasmAllocator* allocator,
+                                     WasmInterpreterThread* thread) {
+  wasm_destroy_interpreter_value_array(allocator, &thread->value_stack);
+  wasm_destroy_uint32_array(allocator, &thread->call_stack);
+}
+
+#define F32_SIGN_MASK 0x80000000U
+#define F32_EXP_MASK 0x7f800000U
+#define F32_SIG_MASK 0x007fffffU
+#define F32_EXP_SHIFT 23
+#define F32_EXP_BIAS 127
+#define F64_SIGN_MASK 0x8000000000000000ULL
+#define F64_EXP_MASK 0x7ff0000000000000ULL
+#define F64_SIG_MASK 0x000fffffffffffffULL
+#define F64_EXP_SHIFT 52
+#define F64_EXP_BIAS 1023
+
+static WASM_INLINE int is_nan_f32(uint32_t f32_bits) {
+  return ((f32_bits & F32_EXP_MASK) == F32_EXP_MASK) &&
+         ((f32_bits & F32_SIG_MASK) != 0);
+}
+
+static WASM_INLINE int is_nan_f64(uint64_t f64_bits) {
+  return ((f64_bits & F64_EXP_MASK) == F64_EXP_MASK) &&
+         ((f64_bits & F64_SIG_MASK) != 0);
+}
+
+static WASM_INLINE int get_exp_f32(uint32_t f32_bits) {
+  return (int)((f32_bits & F32_EXP_MASK) >> F32_EXP_SHIFT) - F32_EXP_BIAS;
+}
+
+static WASM_INLINE int get_exp_f64(uint64_t f64_bits) {
+  return (int)((f64_bits & F64_EXP_MASK) >> F64_EXP_SHIFT) - F64_EXP_BIAS;
+}
+
+static WASM_INLINE int is_signed_f32(uint32_t f32_bits) {
+  return (f32_bits & F32_SIGN_MASK) != 0;
+}
+
+static WASM_INLINE int is_signed_f64(uint64_t f64_bits) {
+  return (f64_bits & F64_SIGN_MASK) != 0;
+}
+
+#define IS_NAN_F32 is_nan_f32
+#define IS_NAN_F64 is_nan_f64
+
+#define DEFINE_BITCAST(name, src, dst) \
+  static WASM_INLINE dst name(src x) { \
+    dst result;                        \
+    memcpy(&result, &x, sizeof(dst));  \
+    return result;                     \
+  }
+
+DEFINE_BITCAST(bitcast_u32_to_i32, uint32_t, int32_t)
+DEFINE_BITCAST(bitcast_u64_to_i64, uint64_t, int64_t)
+DEFINE_BITCAST(bitcast_f32_to_u32, float, uint32_t)
+DEFINE_BITCAST(bitcast_u32_to_f32, uint32_t, float)
+DEFINE_BITCAST(bitcast_f64_to_u64, double, uint64_t)
+DEFINE_BITCAST(bitcast_u64_to_f64, uint64_t, double)
+
+#define bitcast_i32_to_u32(x) ((uint32_t)x)
+#define bitcast_i64_to_u64(x) ((uint64_t)x)
+
+#define VALUE_TYPE_I32 uint32_t
+#define VALUE_TYPE_I64 uint64_t
+#define VALUE_TYPE_F32 uint32_t
+#define VALUE_TYPE_F64 uint64_t
+
+#define FLOAT_TYPE_F32 float
+#define FLOAT_TYPE_F64 double
+
+#define MEM_TYPE_I8 int8_t
+#define MEM_TYPE_U8 uint8_t
+#define MEM_TYPE_I16 int16_t
+#define MEM_TYPE_U16 uint16_t
+#define MEM_TYPE_I32 int32_t
+#define MEM_TYPE_U32 uint32_t
+#define MEM_TYPE_I64 int64_t
+#define MEM_TYPE_U64 uint64_t
+#define MEM_TYPE_F32 uint32_t
+#define MEM_TYPE_F64 uint64_t
+
+#define MEM_TYPE_EXTEND_I32_I8 int32_t
+#define MEM_TYPE_EXTEND_I32_U8 uint32_t
+#define MEM_TYPE_EXTEND_I32_I16 int32_t
+#define MEM_TYPE_EXTEND_I32_U16 uint32_t
+#define MEM_TYPE_EXTEND_I32_I32 int32_t
+#define MEM_TYPE_EXTEND_I32_U32 uint32_t
+
+#define MEM_TYPE_EXTEND_I64_I8 int64_t
+#define MEM_TYPE_EXTEND_I64_U8 uint64_t
+#define MEM_TYPE_EXTEND_I64_I16 int64_t
+#define MEM_TYPE_EXTEND_I64_U16 uint64_t
+#define MEM_TYPE_EXTEND_I64_I32 int64_t
+#define MEM_TYPE_EXTEND_I64_U32 uint64_t
+#define MEM_TYPE_EXTEND_I64_I64 int64_t
+#define MEM_TYPE_EXTEND_I64_U64 uint64_t
+
+#define MEM_TYPE_EXTEND_F32_F32 uint32_t
+#define MEM_TYPE_EXTEND_F64_F64 uint64_t
+
+#define BITCAST_I32_TO_SIGNED bitcast_u32_to_i32
+#define BITCAST_I64_TO_SIGNED bitcast_u64_to_i64
+#define BITCAST_I32_TO_UNSIGNED bitcast_i32_to_u32
+#define BITCAST_I64_TO_UNSIGNED bitcast_i64_to_u64
+
+#define BITCAST_TO_F32 bitcast_u32_to_f32
+#define BITCAST_TO_F64 bitcast_u64_to_f64
+#define BITCAST_FROM_F32 bitcast_f32_to_u32
+#define BITCAST_FROM_F64 bitcast_f64_to_u64
+
+#define TYPE_FIELD_NAME_I32 i32
+#define TYPE_FIELD_NAME_I64 i64
+#define TYPE_FIELD_NAME_F32 f32_bits
+#define TYPE_FIELD_NAME_F64 f64_bits
+
+#define TRAP(type) return WASM_INTERPRETER_TRAP_##type
+
+#define CHECK_STACK()              \
+  do {                             \
+    if (vs_top >= vs_end)          \
+      TRAP(VALUE_STACK_EXHAUSTED); \
+  } while (0)
+
+#define PUSH(v)        \
+  do {                 \
+    CHECK_STACK();     \
+    (*vs_top++) = (v); \
+  } while (0)
+
+#define PUSH_TYPE(type, v)                                       \
+  do {                                                           \
+    CHECK_STACK();                                               \
+    (*vs_top++).TYPE_FIELD_NAME_##type = (VALUE_TYPE_##type)(v); \
+  } while (0)
+
+#define PUSH_I32(v) PUSH_TYPE(I32, (v))
+#define PUSH_I64(v) PUSH_TYPE(I64, (v))
+#define PUSH_F32(v) PUSH_TYPE(F32, (v))
+#define PUSH_F64(v) PUSH_TYPE(F64, (v))
+
+#define STACK_VALUE(depth) (*(vs_top - (depth)))
+#define TOP() (STACK_VALUE(1))
+#define POP() (*--vs_top)
+#define POP_I32() (POP().i32)
+#define POP_I64() (POP().i64)
+#define POP_F32() (POP().f32_bits)
+#define POP_F64() (POP().f64_bits)
+
+#define GOTO(offset) pc = &istream[offset]
+
+#define PUSH_CALL(o)              \
+  do {                            \
+    if (cs_top >= cs_end)         \
+      TRAP(CALL_STACK_EXHAUSTED); \
+    (*cs_top++) = (pc - istream); \
+  } while (0)
+
+#define POP_CALL() (*--cs_top)
+
+#define LOAD(type, mem_type)                                   \
+  do {                                                         \
+    uint64_t offset = (uint64_t)POP_I32() + read_u32(&pc);     \
+    if (offset >= module->memory.byte_size)                    \
+      TRAP(MEMORY_ACCESS_OUT_OF_BOUNDS);                       \
+    void* src = (void*)((size_t)module->memory.data + offset); \
+    MEM_TYPE_##mem_type value;                                 \
+    memcpy(&value, src, sizeof(MEM_TYPE_##mem_type));          \
+    PUSH_##type((MEM_TYPE_EXTEND_##type##_##mem_type)value);   \
+  } while (0)
+
+#define STORE(type, mem_type)                                  \
+  do {                                                         \
+    VALUE_TYPE_##type value = POP_##type();                    \
+    uint64_t offset = (uint64_t)POP_I32() + read_u32(&pc);     \
+    if (offset >= module->memory.byte_size)                    \
+      TRAP(MEMORY_ACCESS_OUT_OF_BOUNDS);                       \
+    void* dst = (void*)((size_t)module->memory.data + offset); \
+    MEM_TYPE_##mem_type src = (MEM_TYPE_##mem_type)value;      \
+    memcpy(dst, &src, sizeof(MEM_TYPE_##mem_type));            \
+    PUSH_##type(value);                                        \
+  } while (0)
+
+#define BINOP(type, op)                   \
+  do {                                    \
+    VALUE_TYPE_##type rhs = POP_##type(); \
+    VALUE_TYPE_##type lhs = POP_##type(); \
+    PUSH_##type(lhs op rhs);              \
+  } while (0)
+
+#define BINOP_SIGNED(type, op)                           \
+  do {                                                   \
+    VALUE_TYPE_##type rhs = POP_##type();                \
+    VALUE_TYPE_##type lhs = POP_##type();                \
+    PUSH_##type(BITCAST_##type##_TO_SIGNED(lhs)          \
+                    op BITCAST_##type##_TO_SIGNED(rhs)); \
+  } while (0)
+
+#define SHIFT_MASK_I32 31
+#define SHIFT_MASK_I64 63
+
+#define BINOP_SHIFT(type, op, sign)                                          \
+  do {                                                                       \
+    VALUE_TYPE_##type rhs = POP_##type();                                    \
+    VALUE_TYPE_##type lhs = POP_##type();                                    \
+    PUSH_##type(BITCAST_##type##_TO_##sign(lhs) op(rhs& SHIFT_MASK_##type)); \
+  } while (0)
+
+#define ROT_LEFT_0_SHIFT_OP <<
+#define ROT_LEFT_1_SHIFT_OP >>
+#define ROT_RIGHT_0_SHIFT_OP >>
+#define ROT_RIGHT_1_SHIFT_OP <<
+
+#define BINOP_ROT(type, dir)                                               \
+  do {                                                                     \
+    VALUE_TYPE_##type rhs = POP_##type();                                  \
+    VALUE_TYPE_##type lhs = POP_##type();                                  \
+    uint32_t amount = rhs & SHIFT_MASK_##type;                             \
+    if (amount != 0) {                                                     \
+      PUSH_##type(                                                         \
+          (lhs ROT_##dir##_0_SHIFT_OP amount) |                            \
+          (lhs ROT_##dir##_1_SHIFT_OP((SHIFT_MASK_##type + 1) - amount))); \
+    } else {                                                               \
+      PUSH_##type(lhs);                                                    \
+    }                                                                      \
+  } while (0)
+
+#define BINOP_TRAP_ZERO(type, op, sign)                  \
+  do {                                                   \
+    VALUE_TYPE_##type rhs = POP_##type();                \
+    VALUE_TYPE_##type lhs = POP_##type();                \
+    if (rhs == 0)                                        \
+      TRAP(INTEGER_DIVIDE_BY_ZERO);                      \
+    PUSH_##type(BITCAST_##type##_TO_##sign(lhs)          \
+                    op BITCAST_##type##_TO_##sign(rhs)); \
+  } while (0)
+
+#define UNOP_FLOAT(type, func)                                 \
+  do {                                                         \
+    FLOAT_TYPE_##type value = BITCAST_TO_##type(POP_##type()); \
+    PUSH_##type(BITCAST_FROM_##type(func(value)));             \
+    break;                                                     \
+  } while (0)
+
+#define BINOP_FLOAT(type, op)                                \
+  do {                                                       \
+    FLOAT_TYPE_##type rhs = BITCAST_TO_##type(POP_##type()); \
+    FLOAT_TYPE_##type lhs = BITCAST_TO_##type(POP_##type()); \
+    PUSH_##type(BITCAST_FROM_##type(lhs op rhs));            \
+  } while (0)
+
+#define MIN_OP <
+#define MAX_OP >
+
+#define MINMAX_FLOAT(type, op)                                               \
+  do {                                                                       \
+    VALUE_TYPE_##type rhs = POP_##type();                                    \
+    VALUE_TYPE_##type lhs = POP_##type();                                    \
+    VALUE_TYPE_##type result;                                                \
+    if (IS_NAN_##type(lhs)) {                                                \
+      result = lhs;                                                          \
+    } else if (IS_NAN_##type(rhs)) {                                         \
+      result = rhs;                                                          \
+    } else {                                                                 \
+      FLOAT_TYPE_##type float_rhs = BITCAST_TO_##type(rhs);                  \
+      FLOAT_TYPE_##type float_lhs = BITCAST_TO_##type(lhs);                  \
+      result = BITCAST_FROM_##type(float_lhs op##_OP float_rhs ? float_lhs   \
+                                                               : float_rhs); \
+    }                                                                        \
+    PUSH_##type(result);                                                     \
+  } while (0)
+
+static WASM_INLINE uint32_t read_u32(const uint8_t** pc) {
+  uint32_t result;
+  memcpy(&result, *pc, sizeof(uint32_t));
+  *pc += sizeof(uint32_t);
+  return result;
+}
+
+static WASM_INLINE uint32_t read_u32_at(const uint8_t* pc) {
+  uint32_t result;
+  memcpy(&result, pc, sizeof(uint32_t));
+  return result;
+}
+
+static WASM_INLINE uint64_t read_u64(const uint8_t** pc) {
+  uint64_t result;
+  memcpy(&result, *pc, sizeof(uint64_t));
+  *pc += sizeof(uint64_t);
+  return result;
+}
+
+WasmInterpreterResult wasm_run_interpreter(WasmInterpreterModule* module,
+                                           WasmInterpreterThread* thread,
+                                           uint32_t num_instructions) {
+  WasmInterpreterResult result = WASM_INTERPRETER_OK;
+  WasmInterpreterValue* vs_bottom = &thread->value_stack.data[0];
+  WasmInterpreterValue* vs_top = vs_bottom + thread->value_stack_top;
+  WasmInterpreterValue* vs_end = vs_bottom + thread->value_stack.size;
+  uint32_t* cs_bottom = &thread->call_stack.data[0];
+  uint32_t* cs_top = cs_bottom + thread->call_stack_top;
+  uint32_t* cs_end = cs_bottom + thread->call_stack.size;
+
+  const uint8_t* istream = module->istream.start;
+  const uint8_t* pc = &istream[thread->pc];
+  uint32_t i;
+  for (i = 0; i < num_instructions; ++i) {
+    uint8_t opcode = *pc++;
+#if LOG
+    printf("%" PRIzd ": %s\n", (pc - 1) - istream, s_opcode_name[opcode]);
+#endif
+    switch (opcode) {
+      case WASM_OPCODE_SELECT: {
+        VALUE_TYPE_I32 cond = POP_I32();
+        WasmInterpreterValue false_ = POP();
+        WasmInterpreterValue true_ = POP();
+        PUSH(cond ? true_ : false_);
+        break;
+      }
+
+      case WASM_OPCODE_BR:
+        GOTO(read_u32(&pc));
+        break;
+
+      case WASM_OPCODE_BR_IF: {
+        uint32_t new_pc = read_u32(&pc);
+        if (POP_I32())
+          GOTO(new_pc);
+        break;
+      }
+
+      case WASM_OPCODE_BR_TABLE: {
+        uint32_t num_targets = read_u32(&pc);
+        uint32_t table_offset = read_u32(&pc);
+        VALUE_TYPE_I32 key = POP_I32();
+        uint32_t key_offset;
+        key_offset =
+            (key >= num_targets ? num_targets : key) * sizeof(uint32_t);
+        uint32_t new_pc = read_u32_at(istream + table_offset + key_offset);
+        GOTO(new_pc);
+        break;
+      }
+
+      case WASM_OPCODE_RETURN:
+        if (cs_top == cs_bottom) {
+          result = WASM_INTERPRETER_RETURNED;
+          goto exit_loop;
+        }
+        GOTO(POP_CALL());
+        break;
+
+      case WASM_OPCODE_UNREACHABLE:
+        TRAP(UNREACHABLE);
+        break;
+
+      case WASM_OPCODE_I8_CONST:
+        break;
+
+      case WASM_OPCODE_I32_CONST:
+        PUSH_TYPE(I32, read_u32(&pc));
+        break;
+
+      case WASM_OPCODE_I64_CONST:
+        PUSH_TYPE(I64, read_u64(&pc));
+        break;
+
+      case WASM_OPCODE_F32_CONST:
+        PUSH_TYPE(F32, read_u32(&pc));
+        break;
+
+      case WASM_OPCODE_F64_CONST:
+        PUSH_TYPE(F64, read_u64(&pc));
+        break;
+
+      case WASM_OPCODE_GET_LOCAL: {
+        WasmInterpreterValue value = STACK_VALUE(read_u32(&pc));
+        PUSH(value);
+        break;
+      }
+
+      case WASM_OPCODE_SET_LOCAL:
+        STACK_VALUE(read_u32(&pc)) = TOP();
+        break;
+
+      case WASM_OPCODE_CALL_FUNCTION: {
+        uint32_t offset = read_u32(&pc);
+        PUSH_CALL();
+        GOTO(offset);
+        break;
+      }
+
+      case WASM_OPCODE_CALL_INDIRECT: {
+        uint32_t sig_index = read_u32(&pc);
+        VALUE_TYPE_I32 entry_index = POP_I32();
+        if (entry_index >= module->func_table.size)
+          TRAP(UNDEFINED_TABLE_INDEX);
+        WasmInterpreterFuncTableEntry* entry =
+            &module->func_table.data[entry_index];
+        if (entry->sig_index != sig_index)
+          TRAP(INDIRECT_CALL_SIGNATURE_MISMATCH);
+        PUSH_CALL();
+        GOTO(entry->func_offset);
+        break;
+      }
+
+      case WASM_OPCODE_CALL_IMPORT: {
+        uint32_t import_index = read_u32(&pc);
+        assert(import_index < module->imports.size);
+        WasmInterpreterImport* import = &module->imports.data[import_index];
+        uint32_t sig_index = import->sig_index;
+        assert(sig_index < module->sigs.size);
+        WasmInterpreterFuncSignature* sig = &module->sigs.data[sig_index];
+        uint32_t num_args = sig->param_types.size;
+        uint32_t i;
+        assert(num_args <= thread->import_args.size);
+        for (i = num_args; i > 0; --i) {
+          WasmInterpreterValue value = POP();
+          WasmInterpreterTypedValue* arg = &thread->import_args.data[i - 1];
+          arg->type = sig->param_types.data[i - 1];
+          arg->value = value;
+        }
+        assert(import->callback);
+        WasmInterpreterTypedValue call_result =
+            import->callback(module, import, num_args, thread->import_args.data,
+                             import->user_data);
+        if (sig->result_type != WASM_TYPE_VOID) {
+          if (call_result.type != sig->result_type)
+            TRAP(IMPORT_RESULT_TYPE_MISMATCH);
+          PUSH(call_result.value);
+        }
+        break;
+      }
+
+      case WASM_OPCODE_I32_LOAD8_S:
+        LOAD(I32, I8);
+        break;
+
+      case WASM_OPCODE_I32_LOAD8_U:
+        LOAD(I32, U8);
+        break;
+
+      case WASM_OPCODE_I32_LOAD16_S:
+        LOAD(I32, I16);
+        break;
+
+      case WASM_OPCODE_I32_LOAD16_U:
+        LOAD(I32, U16);
+        break;
+
+      case WASM_OPCODE_I64_LOAD8_S:
+        LOAD(I64, I8);
+        break;
+
+      case WASM_OPCODE_I64_LOAD8_U:
+        LOAD(I64, U8);
+        break;
+
+      case WASM_OPCODE_I64_LOAD16_S:
+        LOAD(I64, I16);
+        break;
+
+      case WASM_OPCODE_I64_LOAD16_U:
+        LOAD(I64, U16);
+        break;
+
+      case WASM_OPCODE_I64_LOAD32_S:
+        LOAD(I64, I32);
+        break;
+
+      case WASM_OPCODE_I64_LOAD32_U:
+        LOAD(I64, U32);
+        break;
+
+      case WASM_OPCODE_I32_LOAD:
+        LOAD(I32, U32);
+        break;
+
+      case WASM_OPCODE_I64_LOAD:
+        LOAD(I64, U64);
+        break;
+
+      case WASM_OPCODE_F32_LOAD:
+        LOAD(F32, F32);
+        break;
+
+      case WASM_OPCODE_F64_LOAD:
+        LOAD(F64, F64);
+        break;
+
+      case WASM_OPCODE_I32_STORE8:
+        STORE(I32, U8);
+        break;
+
+      case WASM_OPCODE_I32_STORE16:
+        STORE(I32, U16);
+        break;
+
+      case WASM_OPCODE_I64_STORE8:
+        STORE(I64, U8);
+        break;
+
+      case WASM_OPCODE_I64_STORE16:
+        STORE(I64, U16);
+        break;
+
+      case WASM_OPCODE_I64_STORE32:
+        STORE(I64, U32);
+        break;
+
+      case WASM_OPCODE_I32_STORE:
+        STORE(I32, U32);
+        break;
+
+      case WASM_OPCODE_I64_STORE:
+        STORE(I64, U64);
+        break;
+
+      case WASM_OPCODE_F32_STORE:
+        STORE(F32, F32);
+        break;
+
+      case WASM_OPCODE_F64_STORE:
+        STORE(F64, F64);
+        break;
+
+      case WASM_OPCODE_MEMORY_SIZE:
+        PUSH_TYPE(I32, module->memory.page_size);
+        break;
+
+      case WASM_OPCODE_GROW_MEMORY: {
+        VALUE_TYPE_I32 new_page_size = POP_I32();
+        uint64_t new_byte_size = (uint64_t)new_page_size * WASM_PAGE_SIZE;
+        if (new_byte_size > UINT32_MAX)
+          TRAP(MEMORY_SIZE_OVERFLOW);
+        WasmAllocator* allocator = module->memory.allocator;
+        void* new_data = wasm_realloc(allocator, module->memory.data,
+                                      new_byte_size, WASM_DEFAULT_ALIGN);
+        if (new_data == NULL)
+          TRAP(OUT_OF_MEMORY);
+        module->memory.data = new_data;
+        module->memory.page_size = new_page_size;
+        module->memory.byte_size = new_byte_size;
+        break;
+      }
+
+      case WASM_OPCODE_I32_ADD:
+        BINOP(I32, +);
+        break;
+
+      case WASM_OPCODE_I32_SUB:
+        BINOP(I32, -);
+        break;
+
+      case WASM_OPCODE_I32_MUL:
+        BINOP(I32, *);
+        break;
+
+      case WASM_OPCODE_I32_DIV_S:
+        BINOP_TRAP_ZERO(I32, /, SIGNED);
+        break;
+
+      case WASM_OPCODE_I32_DIV_U:
+        BINOP_TRAP_ZERO(I32, /, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I32_REM_S:
+        BINOP_TRAP_ZERO(I32, %, SIGNED);
+        break;
+
+      case WASM_OPCODE_I32_REM_U:
+        BINOP_TRAP_ZERO(I32, %, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I32_AND:
+        BINOP(I32, &);
+        break;
+
+      case WASM_OPCODE_I32_OR:
+        BINOP(I32, |);
+        break;
+
+      case WASM_OPCODE_I32_XOR:
+        BINOP(I32, ^);
+        break;
+
+      case WASM_OPCODE_I32_SHL:
+        BINOP_SHIFT(I32, <<, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I32_SHR_U:
+        BINOP_SHIFT(I32, >>, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I32_SHR_S:
+        BINOP_SHIFT(I32, >>, SIGNED);
+        break;
+
+      case WASM_OPCODE_I32_EQ:
+        BINOP(I32, ==);
+        break;
+
+      case WASM_OPCODE_I32_NE:
+        BINOP(I32, !=);
+        break;
+
+      case WASM_OPCODE_I32_LT_S:
+        BINOP_SIGNED(I32, <);
+        break;
+
+      case WASM_OPCODE_I32_LE_S:
+        BINOP_SIGNED(I32, <=);
+        break;
+
+      case WASM_OPCODE_I32_LT_U:
+        BINOP(I32, <);
+        break;
+
+      case WASM_OPCODE_I32_LE_U:
+        BINOP(I32, <=);
+        break;
+
+      case WASM_OPCODE_I32_GT_S:
+        BINOP_SIGNED(I32, >);
+        break;
+
+      case WASM_OPCODE_I32_GE_S:
+        BINOP_SIGNED(I32, >=);
+        break;
+
+      case WASM_OPCODE_I32_GT_U:
+        BINOP(I32, >);
+        break;
+
+      case WASM_OPCODE_I32_GE_U:
+        BINOP(I32, >=);
+        break;
+
+      case WASM_OPCODE_I32_CLZ: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_I32(value != 0 ? wasm_clz_u32(value) : 32);
+        break;
+      }
+
+      case WASM_OPCODE_I32_CTZ: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_I32(value != 0 ? wasm_ctz_u32(value) : 32);
+        break;
+      }
+
+      case WASM_OPCODE_I32_POPCNT: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_I32(wasm_popcount_u32(value));
+        break;
+      }
+
+      case WASM_OPCODE_I32_EQZ: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_I32(value == 0);
+        break;
+      }
+
+      case WASM_OPCODE_I64_ADD:
+        BINOP(I64, +);
+        break;
+
+      case WASM_OPCODE_I64_SUB:
+        BINOP(I64, -);
+        break;
+
+      case WASM_OPCODE_I64_MUL:
+        BINOP(I64, *);
+        break;
+
+      case WASM_OPCODE_I64_DIV_S:
+        BINOP_TRAP_ZERO(I64, /, SIGNED);
+        break;
+
+      case WASM_OPCODE_I64_DIV_U:
+        BINOP_TRAP_ZERO(I64, /, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I64_REM_S:
+        BINOP_TRAP_ZERO(I64, %, SIGNED);
+        break;
+
+      case WASM_OPCODE_I64_REM_U:
+        BINOP_TRAP_ZERO(I64, %, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I64_AND:
+        BINOP(I64, &);
+        break;
+
+      case WASM_OPCODE_I64_OR:
+        BINOP(I64, |);
+        break;
+
+      case WASM_OPCODE_I64_XOR:
+        BINOP(I64, ^);
+        break;
+
+      case WASM_OPCODE_I64_SHL:
+        BINOP_SHIFT(I64, <<, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I64_SHR_U:
+        BINOP_SHIFT(I64, >>, UNSIGNED);
+        break;
+
+      case WASM_OPCODE_I64_SHR_S:
+        BINOP_SHIFT(I64, >>, SIGNED);
+        break;
+
+      case WASM_OPCODE_I64_EQ:
+        BINOP(I64, ==);
+        break;
+
+      case WASM_OPCODE_I64_NE:
+        BINOP(I64, !=);
+        break;
+
+      case WASM_OPCODE_I64_LT_S:
+        BINOP_SIGNED(I64, <);
+        break;
+
+      case WASM_OPCODE_I64_LE_S:
+        BINOP_SIGNED(I64, <=);
+        break;
+
+      case WASM_OPCODE_I64_LT_U:
+        BINOP(I64, <);
+        break;
+
+      case WASM_OPCODE_I64_LE_U:
+        BINOP(I64, <=);
+        break;
+
+      case WASM_OPCODE_I64_GT_S:
+        BINOP_SIGNED(I64, >);
+        break;
+
+      case WASM_OPCODE_I64_GE_S:
+        BINOP_SIGNED(I64, >=);
+        break;
+
+      case WASM_OPCODE_I64_GT_U:
+        BINOP(I64, >);
+        break;
+
+      case WASM_OPCODE_I64_GE_U:
+        BINOP(I64, >=);
+        break;
+
+      case WASM_OPCODE_I64_CLZ: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_I64(value != 0 ? wasm_clz_u64(value) : 64);
+        break;
+      }
+
+      case WASM_OPCODE_I64_CTZ: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_I64(value != 0 ? wasm_ctz_u64(value) : 64);
+        break;
+      }
+
+      case WASM_OPCODE_I64_POPCNT: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_I64(wasm_popcount_u64(value));
+        break;
+      }
+
+      case WASM_OPCODE_F32_ADD:
+        BINOP_FLOAT(F32, +);
+        break;
+
+      case WASM_OPCODE_F32_SUB:
+        BINOP_FLOAT(F32, -);
+        break;
+
+      case WASM_OPCODE_F32_MUL:
+        BINOP_FLOAT(F32, *);
+        break;
+
+      case WASM_OPCODE_F32_DIV:
+        BINOP_FLOAT(F32, /);
+        break;
+
+      case WASM_OPCODE_F32_MIN:
+        MINMAX_FLOAT(F32, MIN);
+        break;
+
+      case WASM_OPCODE_F32_MAX:
+        MINMAX_FLOAT(F32, MAX);
+        break;
+
+      case WASM_OPCODE_F32_ABS:
+        TOP().f32_bits &= ~F32_SIGN_MASK;
+        break;
+
+      case WASM_OPCODE_F32_NEG:
+        TOP().f32_bits ^= F32_SIGN_MASK;
+        break;
+
+      case WASM_OPCODE_F32_COPYSIGN: {
+        VALUE_TYPE_F32 rhs = POP_F32();
+        VALUE_TYPE_F32 lhs = POP_F32();
+        PUSH_F32((lhs & ~F32_SIGN_MASK) | (rhs & F32_SIGN_MASK));
+        break;
+      }
+
+      case WASM_OPCODE_F32_CEIL:
+        UNOP_FLOAT(F32, ceilf);
+        break;
+
+      case WASM_OPCODE_F32_FLOOR:
+        UNOP_FLOAT(F32, floorf);
+        break;
+
+      case WASM_OPCODE_F32_TRUNC:
+        UNOP_FLOAT(F32, truncf);
+        break;
+
+      case WASM_OPCODE_F32_NEAREST:
+        UNOP_FLOAT(F32, nearbyintf);
+        break;
+
+      case WASM_OPCODE_F32_SQRT:
+        UNOP_FLOAT(F32, sqrtf);
+        break;
+
+      case WASM_OPCODE_F32_EQ:
+        BINOP_FLOAT(F32, ==);
+        break;
+
+      case WASM_OPCODE_F32_NE:
+        BINOP_FLOAT(F32, !=);
+        break;
+
+      case WASM_OPCODE_F32_LT:
+        BINOP_FLOAT(F32, <);
+        break;
+
+      case WASM_OPCODE_F32_LE:
+        BINOP_FLOAT(F32, <=);
+        break;
+
+      case WASM_OPCODE_F32_GT:
+        BINOP_FLOAT(F32, >);
+        break;
+
+      case WASM_OPCODE_F32_GE:
+        BINOP_FLOAT(F32, >=);
+        break;
+
+      case WASM_OPCODE_F64_ADD:
+        BINOP_FLOAT(F64, +);
+        break;
+
+      case WASM_OPCODE_F64_SUB:
+        BINOP_FLOAT(F64, -);
+        break;
+
+      case WASM_OPCODE_F64_MUL:
+        BINOP_FLOAT(F64, *);
+        break;
+
+      case WASM_OPCODE_F64_DIV:
+        BINOP_FLOAT(F64, /);
+        break;
+
+      case WASM_OPCODE_F64_MIN:
+        MINMAX_FLOAT(F64, MIN);
+        break;
+
+      case WASM_OPCODE_F64_MAX:
+        MINMAX_FLOAT(F64, MAX);
+        break;
+
+      case WASM_OPCODE_F64_ABS:
+        TOP().f64_bits &= ~F64_SIGN_MASK;
+        break;
+
+      case WASM_OPCODE_F64_NEG:
+        TOP().f64_bits ^= F64_SIGN_MASK;
+        break;
+
+      case WASM_OPCODE_F64_COPYSIGN: {
+        VALUE_TYPE_F64 rhs = POP_F64();
+        VALUE_TYPE_F64 lhs = POP_F64();
+        PUSH_F64((lhs & ~F64_SIGN_MASK) | (rhs & F64_SIGN_MASK));
+        break;
+      }
+
+      case WASM_OPCODE_F64_CEIL:
+        UNOP_FLOAT(F64, ceilf);
+        break;
+
+      case WASM_OPCODE_F64_FLOOR:
+        UNOP_FLOAT(F64, floorf);
+        break;
+
+      case WASM_OPCODE_F64_TRUNC:
+        UNOP_FLOAT(F64, truncf);
+        break;
+
+      case WASM_OPCODE_F64_NEAREST:
+        UNOP_FLOAT(F64, nearbyintf);
+        break;
+
+      case WASM_OPCODE_F64_SQRT:
+        UNOP_FLOAT(F64, sqrtf);
+        break;
+
+      case WASM_OPCODE_F64_EQ:
+        BINOP_FLOAT(F64, ==);
+        break;
+
+      case WASM_OPCODE_F64_NE:
+        BINOP_FLOAT(F64, !=);
+        break;
+
+      case WASM_OPCODE_F64_LT:
+        BINOP_FLOAT(F64, <);
+        break;
+
+      case WASM_OPCODE_F64_LE:
+        BINOP_FLOAT(F64, <=);
+        break;
+
+      case WASM_OPCODE_F64_GT:
+        BINOP_FLOAT(F64, >);
+        break;
+
+      case WASM_OPCODE_F64_GE:
+        BINOP_FLOAT(F64, >=);
+        break;
+
+      case WASM_OPCODE_I32_TRUNC_S_F32: {
+        VALUE_TYPE_F32 value = POP_F32();
+        if (is_nan_f32(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f32(value);
+        if (exp > 31)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I32((int32_t)BITCAST_TO_F32(value));
+        break;
+      }
+
+      case WASM_OPCODE_I32_TRUNC_S_F64: {
+        VALUE_TYPE_F64 value = POP_F64();
+        if (is_nan_f64(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f64(value);
+        if (exp >= 31)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I32((int32_t)BITCAST_TO_F64(value));
+        break;
+      }
+
+      case WASM_OPCODE_I32_TRUNC_U_F32: {
+        VALUE_TYPE_F32 value = POP_F32();
+        if (is_nan_f32(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f32(value);
+        if (is_signed_f32(value) || exp >= 32)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I32((uint32_t)BITCAST_TO_F32(value));
+        break;
+      }
+
+      case WASM_OPCODE_I32_TRUNC_U_F64: {
+        VALUE_TYPE_F64 value = POP_F64();
+        if (is_nan_f64(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f64(value);
+        if (is_signed_f64(value) || exp >= 32)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I32((uint32_t)BITCAST_TO_F64(value));
+        break;
+      }
+
+      case WASM_OPCODE_I32_WRAP_I64: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_I32((uint32_t)value);
+        break;
+      }
+
+      case WASM_OPCODE_I64_TRUNC_S_F32: {
+        VALUE_TYPE_F32 value = POP_F32();
+        if (is_nan_f32(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f32(value);
+        if (exp >= 63)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I64((int64_t)BITCAST_TO_F32(value));
+        break;
+      }
+
+      case WASM_OPCODE_I64_TRUNC_S_F64: {
+        VALUE_TYPE_F64 value = POP_F64();
+        if (is_nan_f64(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f64(value);
+        if (exp >= 63)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I64((int64_t)BITCAST_TO_F64(value));
+        break;
+      }
+
+      case WASM_OPCODE_I64_TRUNC_U_F32: {
+        VALUE_TYPE_F32 value = POP_F32();
+        if (is_nan_f32(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f32(value);
+        if (is_signed_f64(value) || exp >= 64)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I64((uint64_t)BITCAST_TO_F32(value));
+        break;
+      }
+
+      case WASM_OPCODE_I64_TRUNC_U_F64: {
+        VALUE_TYPE_F64 value = POP_F64();
+        if (is_nan_f64(value))
+          TRAP(INVALID_CONVERSION_TO_INTEGER);
+        int exp = get_exp_f64(value);
+        if (is_signed_f64(value) || exp >= 64)
+          TRAP(INTEGER_OVERFLOW);
+        PUSH_I64((uint64_t)BITCAST_TO_F64(value));
+        break;
+      }
+
+      case WASM_OPCODE_I64_EXTEND_S_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_I64((int64_t)BITCAST_I32_TO_SIGNED(value));
+        break;
+      }
+
+      case WASM_OPCODE_I64_EXTEND_U_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_I64((uint64_t)value);
+        break;
+      }
+
+      case WASM_OPCODE_F32_CONVERT_S_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_F32(BITCAST_FROM_F32((float)BITCAST_I32_TO_SIGNED(value)));
+        break;
+      }
+
+      case WASM_OPCODE_F32_CONVERT_U_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_F32(BITCAST_FROM_F32((float)value));
+        break;
+      }
+
+      case WASM_OPCODE_F32_CONVERT_S_I64: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_F32(BITCAST_FROM_F32((float)BITCAST_I64_TO_SIGNED(value)));
+        break;
+      }
+
+      case WASM_OPCODE_F32_CONVERT_U_I64: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_F32(BITCAST_FROM_F32((float)value));
+        break;
+      }
+
+      case WASM_OPCODE_F32_DEMOTE_F64: {
+        VALUE_TYPE_F64 value = POP_F64();
+        PUSH_F32(BITCAST_FROM_F32((float)BITCAST_TO_F64(value)));
+        break;
+      }
+
+      case WASM_OPCODE_F32_REINTERPRET_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_F32(value);
+        break;
+      }
+
+      case WASM_OPCODE_F64_CONVERT_S_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_F64(BITCAST_FROM_F64((float)BITCAST_I32_TO_SIGNED(value)));
+        break;
+      }
+
+      case WASM_OPCODE_F64_CONVERT_U_I32: {
+        VALUE_TYPE_I32 value = POP_I32();
+        PUSH_F64(BITCAST_FROM_F64((float)value));
+        break;
+      }
+
+      case WASM_OPCODE_F64_CONVERT_S_I64: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_F64(BITCAST_FROM_F64((float)BITCAST_I64_TO_SIGNED(value)));
+        break;
+      }
+
+      case WASM_OPCODE_F64_CONVERT_U_I64: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_F64(BITCAST_FROM_F64((float)value));
+        break;
+      }
+
+      case WASM_OPCODE_F64_PROMOTE_F32: {
+        VALUE_TYPE_F32 value = POP_F32();
+        PUSH_F64(BITCAST_FROM_F64((double)BITCAST_TO_F32(value)));
+        break;
+      }
+
+      case WASM_OPCODE_F64_REINTERPRET_I64: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_F64(value);
+        break;
+      }
+
+      case WASM_OPCODE_I32_REINTERPRET_F32: {
+        VALUE_TYPE_F32 value = POP_F32();
+        PUSH_I32(value);
+        break;
+      }
+
+      case WASM_OPCODE_I64_REINTERPRET_F64: {
+        VALUE_TYPE_F64 value = POP_F64();
+        PUSH_I64(value);
+        break;
+      }
+
+      case WASM_OPCODE_I32_ROTR:
+        BINOP_ROT(I32, RIGHT);
+        break;
+
+      case WASM_OPCODE_I32_ROTL:
+        BINOP_ROT(I32, LEFT);
+        break;
+
+      case WASM_OPCODE_I64_ROTR:
+        BINOP_ROT(I64, RIGHT);
+        break;
+
+      case WASM_OPCODE_I64_ROTL:
+        BINOP_ROT(I64, LEFT);
+        break;
+
+      case WASM_OPCODE_I64_EQZ: {
+        VALUE_TYPE_I64 value = POP_I64();
+        PUSH_I64(value == 0);
+        break;
+      }
+
+      case WASM_OPCODE_ALLOCA: {
+        WasmInterpreterValue* old_vs_top = vs_top;
+        vs_top += read_u32(&pc);
+        CHECK_STACK();
+        memset(old_vs_top, 0, vs_top - old_vs_top);
+        break;
+      }
+
+      case WASM_OPCODE_DISCARD:
+        POP();
+        break;
+
+      case WASM_OPCODE_DISCARD_KEEP: {
+        uint32_t discard_count = read_u32(&pc);
+        uint8_t keep_count = *pc++;
+        assert(keep_count <= 1);
+        if (keep_count == 1)
+          STACK_VALUE(discard_count + 1) = TOP();
+        vs_top -= discard_count;
+        break;
+      }
+
+      default:
+        assert(0);
+        break;
+    }
+  }
+
+exit_loop:
+  thread->value_stack_top = vs_top - vs_bottom;
+  thread->call_stack_top = cs_top - cs_bottom;
+  thread->pc = pc - istream;
+  return result;
+}
+
+#if 0
+void wasm_trace_pc(WasmInterpreterModule* module,
+                   WasmInterpreterThread* thread) {
+  const uint8_t* istream = module->istream.start;
+  const uint8_t* pc = &istream[thread->pc];
+  uint8_t opcode = *pc++;
+  switch (opcode) {
+    case WASM_OPCODE_SELECT:
+      printf("select %u, %" PRIu64 ", %" PRIu64 "\n", STACK_VALUE(3).u32,
+             STACK_VALUE(2).u64, STACK_VALUE(1).u64);
+      break;
+
+    case WASM_OPCODE_BR:
+      printf("br @%u\n", read_u32_at(pc));
+      break;
+
+    case WASM_OPCODE_BR_IF:
+      printf("br_if @%u, %u\n", read_u32_at(pc), STACK_VALUE(1).u32);
+      break;
+
+    case WASM_OPCODE_BR_TABLE: {
+      uint32_t num_targets = read_u32(&pc);
+      uint32_t table_offset = read_u32(&pc);
+      VALUE_TYPE_I32 key = POP_I32();
+      uint32_t key_offset;
+      key_offset =
+          (key >= num_targets ? num_targets : key) * sizeof(uint32_t);
+      uint32_t new_pc = read_u32_at(istream + table_offset + key_offset);
+      GOTO(new_pc);
+      break;
+    }
+
+    case WASM_OPCODE_RETURN:
+      if (cs_top > 0) {
+        result = WASM_INTERPRETER_RETURNED;
+        goto exit_loop;
+      }
+      GOTO(POP_CALL());
+      break;
+
+    case WASM_OPCODE_UNREACHABLE:
+      TRAP(UNREACHABLE);
+      break;
+
+    case WASM_OPCODE_I8_CONST:
+      break;
+
+    case WASM_OPCODE_I32_CONST:
+      PUSH_TYPE(I32, read_u32(&pc));
+      break;
+
+    case WASM_OPCODE_I64_CONST:
+      PUSH_TYPE(I64, read_u64(&pc));
+      break;
+
+    case WASM_OPCODE_F32_CONST:
+      PUSH_TYPE(F32, read_u32(&pc));
+      break;
+
+    case WASM_OPCODE_F64_CONST:
+      PUSH_TYPE(F64, read_u64(&pc));
+      break;
+
+    case WASM_OPCODE_GET_LOCAL: {
+      WasmInterpreterValue value = STACK_VALUE(read_u32(&pc));
+      PUSH(value);
+      break;
+    }
+
+    case WASM_OPCODE_SET_LOCAL:
+      STACK_VALUE(read_u32(&pc)) = TOP();
+      break;
+
+    case WASM_OPCODE_CALL_FUNCTION: {
+      uint32_t offset = read_u32(&pc);
+      PUSH_CALL(offset);
+      GOTO(offset);
+      break;
+    }
+
+    case WASM_OPCODE_CALL_INDIRECT: {
+      uint32_t sig_index = read_u32(&pc);
+      VALUE_TYPE_I32 entry_index = POP_I32();
+      if (entry_index >= module->func_table.size)
+        TRAP(UNDEFINED_TABLE_INDEX);
+      WasmInterpreterFuncTableEntry* entry =
+          &module->func_table.data[entry_index];
+      if (entry->sig_index != sig_index)
+        TRAP(INDIRECT_CALL_SIGNATURE_MISMATCH);
+      PUSH_CALL(entry->func_offset);
+      GOTO(entry->func_offset);
+      break;
+    }
+
+    case WASM_OPCODE_CALL_IMPORT: {
+      uint32_t import_index = read_u32(&pc);
+      assert(import_index < module->imports.size);
+      WasmInterpreterImport* import = &module->imports.data[import_index];
+      uint32_t sig_index = import->sig_index;
+      assert(sig_index < module->sigs.size);
+      WasmInterpreterFuncSignature* sig = &module->sigs.data[sig_index];
+      uint32_t num_args = sig->param_types.size;
+      uint32_t i;
+      assert(num_args <= thread->import_args.size);
+      for (i = num_args; i > 0; --i) {
+        WasmInterpreterValue value = POP();
+        WasmInterpreterTypedValue* arg = &thread->import_args.data[i - 1];
+        arg->type = sig->param_types.data[i - 1];
+        arg->value = value;
+      }
+      assert(import->callback);
+      WasmInterpreterTypedValue call_result =
+          import->callback(module, import, num_args, thread->import_args.data,
+                           import->user_data);
+      if (sig->result_type != WASM_TYPE_VOID) {
+        if (call_result.type != sig->result_type)
+          TRAP(IMPORT_RESULT_TYPE_MISMATCH);
+        PUSH(call_result.value);
+      }
+      break;
+    }
+
+    case WASM_OPCODE_I32_LOAD8_S:
+      LOAD(I32, I8);
+      break;
+
+    case WASM_OPCODE_I32_LOAD8_U:
+      LOAD(I32, U8);
+      break;
+
+    case WASM_OPCODE_I32_LOAD16_S:
+      LOAD(I32, I16);
+      break;
+
+    case WASM_OPCODE_I32_LOAD16_U:
+      LOAD(I32, U16);
+      break;
+
+    case WASM_OPCODE_I64_LOAD8_S:
+      LOAD(I64, I8);
+      break;
+
+    case WASM_OPCODE_I64_LOAD8_U:
+      LOAD(I64, U8);
+      break;
+
+    case WASM_OPCODE_I64_LOAD16_S:
+      LOAD(I64, I16);
+      break;
+
+    case WASM_OPCODE_I64_LOAD16_U:
+      LOAD(I64, U16);
+      break;
+
+    case WASM_OPCODE_I64_LOAD32_S:
+      LOAD(I64, I32);
+      break;
+
+    case WASM_OPCODE_I64_LOAD32_U:
+      LOAD(I64, U32);
+      break;
+
+    case WASM_OPCODE_I32_LOAD:
+      LOAD(I32, U32);
+      break;
+
+    case WASM_OPCODE_I64_LOAD:
+      LOAD(I64, U64);
+      break;
+
+    case WASM_OPCODE_F32_LOAD:
+      LOAD(F32, F32);
+      break;
+
+    case WASM_OPCODE_F64_LOAD:
+      LOAD(F64, F64);
+      break;
+
+    case WASM_OPCODE_I32_STORE8:
+      STORE(I32, U8);
+      break;
+
+    case WASM_OPCODE_I32_STORE16:
+      STORE(I32, U16);
+      break;
+
+    case WASM_OPCODE_I64_STORE8:
+      STORE(I64, U8);
+      break;
+
+    case WASM_OPCODE_I64_STORE16:
+      STORE(I64, U16);
+      break;
+
+    case WASM_OPCODE_I64_STORE32:
+      STORE(I64, U32);
+      break;
+
+    case WASM_OPCODE_I32_STORE:
+      STORE(I32, U32);
+      break;
+
+    case WASM_OPCODE_I64_STORE:
+      STORE(I64, U64);
+      break;
+
+    case WASM_OPCODE_F32_STORE:
+      STORE(F32, F32);
+      break;
+
+    case WASM_OPCODE_F64_STORE:
+      STORE(F64, F64);
+      break;
+
+    case WASM_OPCODE_MEMORY_SIZE:
+      PUSH_TYPE(I32, module->memory.page_size);
+      break;
+
+    case WASM_OPCODE_GROW_MEMORY: {
+      VALUE_TYPE_I32 new_page_size = POP_I32();
+      uint64_t new_byte_size = (uint64_t)new_page_size * WASM_PAGE_SIZE;
+      if (new_byte_size > UINT32_MAX)
+        TRAP(MEMORY_SIZE_OVERFLOW);
+      WasmAllocator* allocator = module->memory.allocator;
+      void* new_data = wasm_realloc(allocator, module->memory.data,
+                                    new_byte_size, WASM_DEFAULT_ALIGN);
+      if (new_data == NULL)
+        TRAP(OUT_OF_MEMORY);
+      module->memory.data = new_data;
+      module->memory.page_size = new_page_size;
+      module->memory.byte_size = new_byte_size;
+      break;
+    }
+
+    case WASM_OPCODE_I32_ADD:
+      BINOP(I32, +);
+      break;
+
+    case WASM_OPCODE_I32_SUB:
+      BINOP(I32, -);
+      break;
+
+    case WASM_OPCODE_I32_MUL:
+      BINOP(I32, *);
+      break;
+
+    case WASM_OPCODE_I32_DIV_S:
+      BINOP_TRAP_ZERO(I32, /, SIGNED);
+      break;
+
+    case WASM_OPCODE_I32_DIV_U:
+      BINOP_TRAP_ZERO(I32, /, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I32_REM_S:
+      BINOP_TRAP_ZERO(I32, %, SIGNED);
+      break;
+
+    case WASM_OPCODE_I32_REM_U:
+      BINOP_TRAP_ZERO(I32, %, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I32_AND:
+      BINOP(I32, &);
+      break;
+
+    case WASM_OPCODE_I32_OR:
+      BINOP(I32, |);
+      break;
+
+    case WASM_OPCODE_I32_XOR:
+      BINOP(I32, ^);
+      break;
+
+    case WASM_OPCODE_I32_SHL:
+      BINOP_SHIFT(I32, <<, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I32_SHR_U:
+      BINOP_SHIFT(I32, >>, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I32_SHR_S:
+      BINOP_SHIFT(I32, >>, SIGNED);
+      break;
+
+    case WASM_OPCODE_I32_EQ:
+      BINOP(I32, ==);
+      break;
+
+    case WASM_OPCODE_I32_NE:
+      BINOP(I32, !=);
+      break;
+
+    case WASM_OPCODE_I32_LT_S:
+      BINOP_SIGNED(I32, <);
+      break;
+
+    case WASM_OPCODE_I32_LE_S:
+      BINOP_SIGNED(I32, <=);
+      break;
+
+    case WASM_OPCODE_I32_LT_U:
+      BINOP(I32, <);
+      break;
+
+    case WASM_OPCODE_I32_LE_U:
+      BINOP(I32, <=);
+      break;
+
+    case WASM_OPCODE_I32_GT_S:
+      BINOP_SIGNED(I32, >);
+      break;
+
+    case WASM_OPCODE_I32_GE_S:
+      BINOP_SIGNED(I32, >=);
+      break;
+
+    case WASM_OPCODE_I32_GT_U:
+      BINOP(I32, >);
+      break;
+
+    case WASM_OPCODE_I32_GE_U:
+      BINOP(I32, >=);
+      break;
+
+    case WASM_OPCODE_I32_CLZ: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_I32(value != 0 ? wasm_clz_u32(value) : 32);
+      break;
+    }
+
+    case WASM_OPCODE_I32_CTZ: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_I32(value != 0 ? wasm_ctz_u32(value) : 32);
+      break;
+    }
+
+    case WASM_OPCODE_I32_POPCNT: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_I32(wasm_popcount_u32(value));
+      break;
+    }
+
+    case WASM_OPCODE_I32_EQZ: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_I32(value == 0);
+      break;
+    }
+
+    case WASM_OPCODE_I64_ADD:
+      BINOP(I64, +);
+      break;
+
+    case WASM_OPCODE_I64_SUB:
+      BINOP(I64, -);
+      break;
+
+    case WASM_OPCODE_I64_MUL:
+      BINOP(I64, *);
+      break;
+
+    case WASM_OPCODE_I64_DIV_S:
+      BINOP_TRAP_ZERO(I64, /, SIGNED);
+      break;
+
+    case WASM_OPCODE_I64_DIV_U:
+      BINOP_TRAP_ZERO(I64, /, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I64_REM_S:
+      BINOP_TRAP_ZERO(I64, %, SIGNED);
+      break;
+
+    case WASM_OPCODE_I64_REM_U:
+      BINOP_TRAP_ZERO(I64, %, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I64_AND:
+      BINOP(I64, &);
+      break;
+
+    case WASM_OPCODE_I64_OR:
+      BINOP(I64, |);
+      break;
+
+    case WASM_OPCODE_I64_XOR:
+      BINOP(I64, ^);
+      break;
+
+    case WASM_OPCODE_I64_SHL:
+      BINOP_SHIFT(I64, <<, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I64_SHR_U:
+      BINOP_SHIFT(I64, >>, UNSIGNED);
+      break;
+
+    case WASM_OPCODE_I64_SHR_S:
+      BINOP_SHIFT(I64, >>, SIGNED);
+      break;
+
+    case WASM_OPCODE_I64_EQ:
+      BINOP(I64, ==);
+      break;
+
+    case WASM_OPCODE_I64_NE:
+      BINOP(I64, !=);
+      break;
+
+    case WASM_OPCODE_I64_LT_S:
+      BINOP_SIGNED(I64, <);
+      break;
+
+    case WASM_OPCODE_I64_LE_S:
+      BINOP_SIGNED(I64, <=);
+      break;
+
+    case WASM_OPCODE_I64_LT_U:
+      BINOP(I64, <);
+      break;
+
+    case WASM_OPCODE_I64_LE_U:
+      BINOP(I64, <=);
+      break;
+
+    case WASM_OPCODE_I64_GT_S:
+      BINOP_SIGNED(I64, >);
+      break;
+
+    case WASM_OPCODE_I64_GE_S:
+      BINOP_SIGNED(I64, >=);
+      break;
+
+    case WASM_OPCODE_I64_GT_U:
+      BINOP(I64, >);
+      break;
+
+    case WASM_OPCODE_I64_GE_U:
+      BINOP(I64, >=);
+      break;
+
+    case WASM_OPCODE_I64_CLZ: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_I64(value != 0 ? wasm_clz_u64(value) : 64);
+      break;
+    }
+
+    case WASM_OPCODE_I64_CTZ: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_I64(value != 0 ? wasm_ctz_u64(value) : 64);
+      break;
+    }
+
+    case WASM_OPCODE_I64_POPCNT: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_I64(wasm_popcount_u64(value));
+      break;
+    }
+
+    case WASM_OPCODE_F32_ADD:
+      BINOP_FLOAT(F32, +);
+      break;
+
+    case WASM_OPCODE_F32_SUB:
+      BINOP_FLOAT(F32, -);
+      break;
+
+    case WASM_OPCODE_F32_MUL:
+      BINOP_FLOAT(F32, *);
+      break;
+
+    case WASM_OPCODE_F32_DIV:
+      BINOP_FLOAT(F32, /);
+      break;
+
+    case WASM_OPCODE_F32_MIN:
+      MINMAX_FLOAT(F32, MIN);
+      break;
+
+    case WASM_OPCODE_F32_MAX:
+      MINMAX_FLOAT(F32, MAX);
+      break;
+
+    case WASM_OPCODE_F32_ABS:
+      TOP().f32_bits &= ~F32_SIGN_MASK;
+      break;
+
+    case WASM_OPCODE_F32_NEG:
+      TOP().f32_bits ^= F32_SIGN_MASK;
+      break;
+
+    case WASM_OPCODE_F32_COPYSIGN: {
+      VALUE_TYPE_F32 rhs = POP_F32();
+      VALUE_TYPE_F32 lhs = POP_F32();
+      PUSH_F32((lhs & ~F32_SIGN_MASK) | (rhs & F32_SIGN_MASK));
+      break;
+    }
+
+    case WASM_OPCODE_F32_CEIL:
+      UNOP_FLOAT(F32, ceilf);
+      break;
+
+    case WASM_OPCODE_F32_FLOOR:
+      UNOP_FLOAT(F32, floorf);
+      break;
+
+    case WASM_OPCODE_F32_TRUNC:
+      UNOP_FLOAT(F32, truncf);
+      break;
+
+    case WASM_OPCODE_F32_NEAREST:
+      UNOP_FLOAT(F32, nearbyintf);
+      break;
+
+    case WASM_OPCODE_F32_SQRT:
+      UNOP_FLOAT(F32, sqrtf);
+      break;
+
+    case WASM_OPCODE_F32_EQ:
+      BINOP_FLOAT(F32, ==);
+      break;
+
+    case WASM_OPCODE_F32_NE:
+      BINOP_FLOAT(F32, !=);
+      break;
+
+    case WASM_OPCODE_F32_LT:
+      BINOP_FLOAT(F32, <);
+      break;
+
+    case WASM_OPCODE_F32_LE:
+      BINOP_FLOAT(F32, <=);
+      break;
+
+    case WASM_OPCODE_F32_GT:
+      BINOP_FLOAT(F32, >);
+      break;
+
+    case WASM_OPCODE_F32_GE:
+      BINOP_FLOAT(F32, >=);
+      break;
+
+    case WASM_OPCODE_F64_ADD:
+      BINOP_FLOAT(F64, +);
+      break;
+
+    case WASM_OPCODE_F64_SUB:
+      BINOP_FLOAT(F64, -);
+      break;
+
+    case WASM_OPCODE_F64_MUL:
+      BINOP_FLOAT(F64, *);
+      break;
+
+    case WASM_OPCODE_F64_DIV:
+      BINOP_FLOAT(F64, /);
+      break;
+
+    case WASM_OPCODE_F64_MIN:
+      MINMAX_FLOAT(F64, MIN);
+      break;
+
+    case WASM_OPCODE_F64_MAX:
+      MINMAX_FLOAT(F64, MAX);
+      break;
+
+    case WASM_OPCODE_F64_ABS:
+      TOP().f64_bits &= ~F64_SIGN_MASK;
+      break;
+
+    case WASM_OPCODE_F64_NEG:
+      TOP().f64_bits ^= F64_SIGN_MASK;
+      break;
+
+    case WASM_OPCODE_F64_COPYSIGN: {
+      VALUE_TYPE_F64 rhs = POP_F64();
+      VALUE_TYPE_F64 lhs = POP_F64();
+      PUSH_F64((lhs & ~F64_SIGN_MASK) | (rhs & F64_SIGN_MASK));
+      break;
+    }
+
+    case WASM_OPCODE_F64_CEIL:
+      UNOP_FLOAT(F64, ceilf);
+      break;
+
+    case WASM_OPCODE_F64_FLOOR:
+      UNOP_FLOAT(F64, floorf);
+      break;
+
+    case WASM_OPCODE_F64_TRUNC:
+      UNOP_FLOAT(F64, truncf);
+      break;
+
+    case WASM_OPCODE_F64_NEAREST:
+      UNOP_FLOAT(F64, nearbyintf);
+      break;
+
+    case WASM_OPCODE_F64_SQRT:
+      UNOP_FLOAT(F64, sqrtf);
+      break;
+
+    case WASM_OPCODE_F64_EQ:
+      BINOP_FLOAT(F64, ==);
+      break;
+
+    case WASM_OPCODE_F64_NE:
+      BINOP_FLOAT(F64, !=);
+      break;
+
+    case WASM_OPCODE_F64_LT:
+      BINOP_FLOAT(F64, <);
+      break;
+
+    case WASM_OPCODE_F64_LE:
+      BINOP_FLOAT(F64, <=);
+      break;
+
+    case WASM_OPCODE_F64_GT:
+      BINOP_FLOAT(F64, >);
+      break;
+
+    case WASM_OPCODE_F64_GE:
+      BINOP_FLOAT(F64, >=);
+      break;
+
+    case WASM_OPCODE_I32_TRUNC_S_F32: {
+      VALUE_TYPE_F32 value = POP_F32();
+      if (is_nan_f32(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f32(value);
+      if (exp > 31)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I32((int32_t)BITCAST_TO_F32(value));
+      break;
+    }
+
+    case WASM_OPCODE_I32_TRUNC_S_F64: {
+      VALUE_TYPE_F64 value = POP_F64();
+      if (is_nan_f64(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f64(value);
+      if (exp >= 31)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I32((int32_t)BITCAST_TO_F64(value));
+      break;
+    }
+
+    case WASM_OPCODE_I32_TRUNC_U_F32: {
+      VALUE_TYPE_F32 value = POP_F32();
+      if (is_nan_f32(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f32(value);
+      if (is_signed_f32(value) || exp >= 32)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I32((uint32_t)BITCAST_TO_F32(value));
+      break;
+    }
+
+    case WASM_OPCODE_I32_TRUNC_U_F64: {
+      VALUE_TYPE_F64 value = POP_F64();
+      if (is_nan_f64(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f64(value);
+      if (is_signed_f64(value) || exp >= 32)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I32((uint32_t)BITCAST_TO_F64(value));
+      break;
+    }
+
+    case WASM_OPCODE_I32_WRAP_I64: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_I32((uint32_t)value);
+      break;
+    }
+
+    case WASM_OPCODE_I64_TRUNC_S_F32: {
+      VALUE_TYPE_F32 value = POP_F32();
+      if (is_nan_f32(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f32(value);
+      if (exp >= 63)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I64((int64_t)BITCAST_TO_F32(value));
+      break;
+    }
+
+    case WASM_OPCODE_I64_TRUNC_S_F64: {
+      VALUE_TYPE_F64 value = POP_F64();
+      if (is_nan_f64(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f64(value);
+      if (exp >= 63)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I64((int64_t)BITCAST_TO_F64(value));
+      break;
+    }
+
+    case WASM_OPCODE_I64_TRUNC_U_F32: {
+      VALUE_TYPE_F32 value = POP_F32();
+      if (is_nan_f32(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f32(value);
+      if (is_signed_f64(value) || exp >= 64)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I64((uint64_t)BITCAST_TO_F32(value));
+      break;
+    }
+
+    case WASM_OPCODE_I64_TRUNC_U_F64: {
+      VALUE_TYPE_F64 value = POP_F64();
+      if (is_nan_f64(value))
+        TRAP(INVALID_CONVERSION_TO_INTEGER);
+      int exp = get_exp_f64(value);
+      if (is_signed_f64(value) || exp >= 64)
+        TRAP(INTEGER_OVERFLOW);
+      PUSH_I64((uint64_t)BITCAST_TO_F64(value));
+      break;
+    }
+
+    case WASM_OPCODE_I64_EXTEND_S_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_I64((int64_t)BITCAST_I32_TO_SIGNED(value));
+      break;
+    }
+
+    case WASM_OPCODE_I64_EXTEND_U_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_I64((uint64_t)value);
+      break;
+    }
+
+    case WASM_OPCODE_F32_CONVERT_S_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_F32(BITCAST_FROM_F32((float)BITCAST_I32_TO_SIGNED(value)));
+      break;
+    }
+
+    case WASM_OPCODE_F32_CONVERT_U_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_F32(BITCAST_FROM_F32((float)value));
+      break;
+    }
+
+    case WASM_OPCODE_F32_CONVERT_S_I64: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_F32(BITCAST_FROM_F32((float)BITCAST_I64_TO_SIGNED(value)));
+      break;
+    }
+
+    case WASM_OPCODE_F32_CONVERT_U_I64: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_F32(BITCAST_FROM_F32((float)value));
+      break;
+    }
+
+    case WASM_OPCODE_F32_DEMOTE_F64: {
+      VALUE_TYPE_F64 value = POP_F64();
+      PUSH_F32(BITCAST_FROM_F32((float)BITCAST_TO_F64(value)));
+      break;
+    }
+
+    case WASM_OPCODE_F32_REINTERPRET_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_F32(value);
+      break;
+    }
+
+    case WASM_OPCODE_F64_CONVERT_S_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_F64(BITCAST_FROM_F64((float)BITCAST_I32_TO_SIGNED(value)));
+      break;
+    }
+
+    case WASM_OPCODE_F64_CONVERT_U_I32: {
+      VALUE_TYPE_I32 value = POP_I32();
+      PUSH_F64(BITCAST_FROM_F64((float)value));
+      break;
+    }
+
+    case WASM_OPCODE_F64_CONVERT_S_I64: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_F64(BITCAST_FROM_F64((float)BITCAST_I64_TO_SIGNED(value)));
+      break;
+    }
+
+    case WASM_OPCODE_F64_CONVERT_U_I64: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_F64(BITCAST_FROM_F64((float)value));
+      break;
+    }
+
+    case WASM_OPCODE_F64_PROMOTE_F32: {
+      VALUE_TYPE_F32 value = POP_F32();
+      PUSH_F64(BITCAST_FROM_F64((double)BITCAST_TO_F32(value)));
+      break;
+    }
+
+    case WASM_OPCODE_F64_REINTERPRET_I64: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_F64(value);
+      break;
+    }
+
+    case WASM_OPCODE_I32_REINTERPRET_F32: {
+      VALUE_TYPE_F32 value = POP_F32();
+      PUSH_I32(value);
+      break;
+    }
+
+    case WASM_OPCODE_I64_REINTERPRET_F64: {
+      VALUE_TYPE_F64 value = POP_F64();
+      PUSH_I64(value);
+      break;
+    }
+
+    case WASM_OPCODE_I32_ROTR:
+      BINOP_ROT(I32, RIGHT);
+      break;
+
+    case WASM_OPCODE_I32_ROTL:
+      BINOP_ROT(I32, LEFT);
+      break;
+
+    case WASM_OPCODE_I64_ROTR:
+      BINOP_ROT(I64, RIGHT);
+      break;
+
+    case WASM_OPCODE_I64_ROTL:
+      BINOP_ROT(I64, LEFT);
+      break;
+
+    case WASM_OPCODE_I64_EQZ: {
+      VALUE_TYPE_I64 value = POP_I64();
+      PUSH_I64(value == 0);
+      break;
+    }
+
+    case WASM_OPCODE_ALLOCA: {
+      WasmInterpreterValue* old_vs_top = vs_top;
+      vs_top += read_u32(&pc);
+      CHECK_STACK();
+      memset(old_vs_top, 0, vs_top - old_vs_top);
+      break;
+    }
+
+    case WASM_OPCODE_DISCARD:
+      POP();
+      break;
+
+    case WASM_OPCODE_DISCARD_KEEP: {
+      uint32_t discard_count = read_u32(&pc);
+      uint8_t keep_count = *pc++;
+      assert(keep_count <= 1);
+      if (keep_count == 1)
+        STACK_VALUE(discard_count + 1) = TOP();
+      vs_top -= discard_count;
+      break;
+    }
+
+    default:
+      assert(0);
+      break;
+  }
+}
+#endif
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
new file mode 100644
index 00000000..91101d4a
--- /dev/null
+++ b/src/wasm-interpreter.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2016 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.
+ */
+
+#ifndef WASM_INTERPRETER_H_
+#define WASM_INTERPRETER_H_
+
+#include <stdint.h>
+
+#include "wasm-array.h"
+#include "wasm-vector.h"
+#include "wasm-writer.h"
+
+#define FOREACH_INTERPRETER_RESULT(V)                                          \
+  V(OK, "ok")                                                                  \
+  /* returned from the top-most function */                                    \
+  V(RETURNED, "returned")                                                      \
+  /* memory access is out of bounds */                                         \
+  V(TRAP_MEMORY_ACCESS_OUT_OF_BOUNDS, "out of bounds memory access")           \
+  /* converting from float -> int would overflow int */                        \
+  V(TRAP_INTEGER_OVERFLOW, "integer overflow")                                 \
+  /* dividend is zero in integer divide */                                     \
+  V(TRAP_INTEGER_DIVIDE_BY_ZERO, "integer divide by zero")                     \
+  /* converting from float -> int where float is nan */                        \
+  V(TRAP_INVALID_CONVERSION_TO_INTEGER, "invalid conversion to integer")       \
+  /* function table index is out of bounds */                                  \
+  V(TRAP_UNDEFINED_TABLE_INDEX, "undefined table index")                       \
+  /* unreachable instruction executed */                                       \
+  V(TRAP_UNREACHABLE, "unreachable executed")                                  \
+  /* call indirect signature doesn't match function table signature */         \
+  V(TRAP_INDIRECT_CALL_SIGNATURE_MISMATCH, "indirect call signature mismatch") \
+  /* growing the memory would overflow the memory size type */                 \
+  V(TRAP_MEMORY_SIZE_OVERFLOW, "memory size overflow")                         \
+  /* out of memory */                                                          \
+  V(TRAP_OUT_OF_MEMORY, "memory size exceeds implementation limit")            \
+  /* ran out of call stack frames (probably infinite recursion) */             \
+  V(TRAP_CALL_STACK_EXHAUSTED, "call stack exhausted")                         \
+  /* ran out of value stack space */                                           \
+  V(TRAP_VALUE_STACK_EXHAUSTED, "value stack exhausted")                       \
+  /* we called an import function, but the return value didn't match the */    \
+  /* expected type */                                                          \
+  V(TRAP_IMPORT_RESULT_TYPE_MISMATCH, "import result type mismatch")
+
+typedef enum WasmInterpreterResult {
+#define V(name, str) WASM_INTERPRETER_##name,
+  FOREACH_INTERPRETER_RESULT(V)
+#undef V
+} WasmInterpreterResult;
+
+#define WASM_INVALID_OFFSET ((uint32_t)~0)
+
+enum {
+  /* push space on the value stack for N entries */
+  WASM_OPCODE_ALLOCA = WASM_LAST_OPCODE,
+  WASM_OPCODE_DISCARD,
+  WASM_OPCODE_DISCARD_KEEP,
+  WASM_LAST_INTERPRETER_OPCODE,
+};
+WASM_STATIC_ASSERT(WASM_LAST_INTERPRETER_OPCODE <= 256);
+
+typedef uint8_t WasmUint8;
+WASM_DEFINE_VECTOR(uint8, WasmUint8);
+WASM_DEFINE_VECTOR(type, WasmType);
+
+/* TODO(binji): identical to WasmFuncSignature. Share? */
+typedef struct WasmInterpreterFuncSignature {
+  WasmType result_type;
+  WasmTypeVector param_types;
+} WasmInterpreterFuncSignature;
+WASM_DEFINE_ARRAY(interpreter_func_signature, WasmInterpreterFuncSignature);
+
+typedef struct WasmInterpreterMemory {
+  WasmAllocator* allocator;
+  void* data;
+  uint32_t page_size;
+  uint32_t byte_size;
+} WasmInterpreterMemory;
+
+typedef struct WasmInterpreterFuncTableEntry {
+  uint32_t sig_index;
+  uint32_t func_offset;
+} WasmInterpreterFuncTableEntry;
+WASM_DEFINE_ARRAY(interpreter_func_table_entry, WasmInterpreterFuncTableEntry);
+
+typedef union WasmInterpreterValue {
+  uint32_t i32;
+  uint64_t i64;
+  uint32_t f32_bits;
+  uint64_t f64_bits;
+} WasmInterpreterValue;
+WASM_DEFINE_ARRAY(interpreter_value, WasmInterpreterValue);
+
+typedef struct WasmInterpreterTypedValue {
+  WasmType type;
+  WasmInterpreterValue value;
+} WasmInterpreterTypedValue;
+WASM_DEFINE_ARRAY(interpreter_typed_value, WasmInterpreterTypedValue);
+
+struct WasmInterpreterModule;
+struct WasmInterpreterImport;
+
+typedef WasmInterpreterTypedValue (*WasmInterpreterImportCallback)(
+    struct WasmInterpreterModule* module,
+    struct WasmInterpreterImport* import,
+    uint32_t num_args,
+    WasmInterpreterTypedValue* args,
+    void* user_data);
+
+typedef struct WasmInterpreterImport {
+  WasmStringSlice module_name;
+  WasmStringSlice func_name;
+  uint32_t sig_index;
+  WasmInterpreterImportCallback callback;
+  void* user_data;
+} WasmInterpreterImport;
+WASM_DEFINE_ARRAY(interpreter_import, WasmInterpreterImport);
+
+typedef struct WasmInterpreterExport {
+  WasmStringSlice name;
+  uint32_t func_offset;
+  uint32_t sig_index;
+} WasmInterpreterExport;
+WASM_DEFINE_ARRAY(interpreter_export, WasmInterpreterExport);
+
+typedef struct WasmInterpreterModule {
+  WasmInterpreterMemory memory;
+  WasmInterpreterFuncSignatureArray sigs;
+  WasmInterpreterFuncTableEntryArray func_table;
+  WasmInterpreterImportArray imports;
+  WasmInterpreterExportArray exports;
+  WasmOutputBuffer istream;
+  uint32_t start_func_offset; /* == WASM_INVALID_OFFSET if not defined */
+} WasmInterpreterModule;
+
+typedef uint32_t WasmUint32;
+WASM_DEFINE_ARRAY(uint32, WasmUint32);
+
+typedef struct WasmInterpreterThread {
+  WasmInterpreterValueArray value_stack;
+  WasmUint32Array call_stack;
+  uint32_t value_stack_top;
+  uint32_t call_stack_top;
+  uint32_t pc;
+
+  /* a temporary buffer that is for passing args to import functions */
+  WasmInterpreterTypedValueArray import_args;
+} WasmInterpreterThread;
+
+typedef struct WasmInterpreterThreadOptions {
+  uint32_t value_stack_size;
+  uint32_t call_stack_size;
+  uint32_t pc;
+} WasmInterpreterThreadOptions;
+
+WASM_EXTERN_C_BEGIN
+WasmResult wasm_init_interpreter_thread(WasmAllocator* allocator,
+                                        WasmInterpreterModule* module,
+                                        WasmInterpreterThread* thread,
+                                        WasmInterpreterThreadOptions* options);
+void wasm_destroy_interpreter_thread(WasmAllocator* allocator,
+                                     WasmInterpreterThread* thread);
+WasmInterpreterResult wasm_run_interpreter(WasmInterpreterModule* module,
+                                           WasmInterpreterThread* thread,
+                                           uint32_t num_instructions);
+void wasm_trace_pc(WasmInterpreterModule* module,
+                   WasmInterpreterThread* thread);
+WASM_EXTERN_C_END
+
+#endif /* WASM_INTERPRETER_H_ */
diff --git a/src/wasm-vector.c b/src/wasm-vector.c
index aa295705..596448c3 100644
--- a/src/wasm-vector.c
+++ b/src/wasm-vector.c
@@ -38,6 +38,25 @@ WasmResult wasm_ensure_capacity(WasmAllocator* allocator,
   return WASM_OK;
 }
 
+WasmResult wasm_resize_vector(struct WasmAllocator* allocator,
+                              void** data,
+                              size_t* size,
+                              size_t* capacity,
+                              size_t desired_size,
+                              size_t elt_byte_size) {
+  size_t old_size = *size;
+  WasmResult result = wasm_ensure_capacity(allocator, data, capacity,
+                                           desired_size, elt_byte_size);
+  if (result != WASM_OK)
+    return result;
+  if (desired_size > old_size) {
+    memset((void*)((size_t)*data + old_size * elt_byte_size), 0,
+           (desired_size - old_size) * elt_byte_size);
+  }
+  *size = desired_size;
+  return WASM_OK;
+}
+
 void* wasm_append_element(WasmAllocator* allocator,
                           void** data,
                           size_t* size,
diff --git a/src/wasm-vector.h b/src/wasm-vector.h
index 1f4a06e0..c210b4cb 100644
--- a/src/wasm-vector.h
+++ b/src/wasm-vector.h
@@ -35,6 +35,8 @@
  *
  * void wasm_destroy_widget_vector(WasmAllocator*, WasmWidgetVector* vec);
  * WasmWidget* wasm_append_widget(WasmAllocator*, WasmWidgetVector* vec);
+ * WasmResult wasm_resize_widget_vector(WasmAllocator*, WasmWidgetVector* vec,
+ *                                      size_t size);
  * WasmResult wasm_reserve_widgets(WasmAllocator*, WasmWidgetVector* vec,
  *                                 size_t desired);
  * WasmResult wasm_append_widget_value(WasmAllocator*, WasmWidgetVector* vec,
@@ -53,6 +55,9 @@
   WASM_EXTERN_C_BEGIN                                                          \
   static WASM_INLINE void wasm_destroy_##name##_vector(                        \
       struct WasmAllocator* allocator, type##Vector* vec) WASM_UNUSED;         \
+  static WASM_INLINE WasmResult wasm_resize_##name##_vector(                   \
+      struct WasmAllocator* allocator, type##Vector* vec, size_t desired)      \
+      WASM_UNUSED;                                                             \
   static WASM_INLINE WasmResult wasm_reserve_##name##s(                        \
       struct WasmAllocator* allocator, type##Vector* vec, size_t desired)      \
       WASM_UNUSED;                                                             \
@@ -70,6 +75,11 @@
                                     type##Vector* vec) {                       \
     wasm_free(allocator, vec->data);                                           \
   }                                                                            \
+  WasmResult wasm_resize_##name##_vector(struct WasmAllocator* allocator,      \
+                                         type##Vector* vec, size_t size) {     \
+    return wasm_resize_vector(allocator, (void**)&vec->data, &vec->size,       \
+                              &vec->capacity, size, sizeof(type));             \
+  }                                                                            \
   WasmResult wasm_reserve_##name##s(struct WasmAllocator* allocator,           \
                                     type##Vector* vec, size_t desired) {       \
     return wasm_ensure_capacity(allocator, (void**)&vec->data, &vec->capacity, \
@@ -110,6 +120,13 @@ WasmResult wasm_ensure_capacity(struct WasmAllocator*,
                                 size_t desired_size,
                                 size_t elt_byte_size) WASM_WARN_UNUSED;
 
+WasmResult wasm_resize_vector(struct WasmAllocator*,
+                              void** data,
+                              size_t* size,
+                              size_t* capacity,
+                              size_t desired_size,
+                              size_t elt_byte_size) WASM_WARN_UNUSED;
+
 void* wasm_append_element(struct WasmAllocator*,
                           void** data,
                           size_t* size,
diff --git a/src/wasm-writer.c b/src/wasm-writer.c
index 1dd7df35..40161008 100644
--- a/src/wasm-writer.c
+++ b/src/wasm-writer.c
@@ -158,6 +158,18 @@ WasmResult wasm_init_mem_writer(WasmAllocator* allocator,
                             INITIAL_OUTPUT_BUFFER_CAPACITY);
 }
 
+void wasm_steal_mem_writer_output_buffer(WasmMemoryWriter* writer,
+                                         WasmOutputBuffer* out_buf) {
+  *out_buf= writer->buf;
+  writer->buf.start = NULL;
+  writer->buf.size = 0;
+  writer->buf.capacity = 0;
+}
+
 void wasm_close_mem_writer(WasmMemoryWriter* writer) {
-  wasm_free(writer->buf.allocator, writer->buf.start);
+  wasm_free_output_buffer(&writer->buf);
+}
+
+void wasm_free_output_buffer(WasmOutputBuffer* buf) {
+  wasm_free(buf->allocator, buf->start);
 }
diff --git a/src/wasm-writer.h b/src/wasm-writer.h
index 792e8cd1..5bb0be89 100644
--- a/src/wasm-writer.h
+++ b/src/wasm-writer.h
@@ -52,11 +52,16 @@ typedef struct WasmFileWriter {
   size_t offset;
 } WasmFileWriter;
 
+WASM_EXTERN_C_BEGIN
 WasmResult wasm_init_file_writer(WasmFileWriter* writer, const char* filename);
 WasmResult wasm_init_file_writer_existing(WasmFileWriter* writer, FILE* file);
 void wasm_close_file_writer(WasmFileWriter* writer);
 WasmResult wasm_init_mem_writer(WasmAllocator* allocator,
                                 WasmMemoryWriter* writer);
+void wasm_steal_mem_writer_output_buffer(WasmMemoryWriter* writer,
+                                         WasmOutputBuffer* out_buf);
 void wasm_close_mem_writer(WasmMemoryWriter* writer);
+void wasm_free_output_buffer(WasmOutputBuffer* buf);
+WASM_EXTERN_C_END
 
 #endif /* WASM_WRITER_H_ */
diff --git a/test/find_exe.py b/test/find_exe.py
index a946388d..4ef2b9db 100644
--- a/test/find_exe.py
+++ b/test/find_exe.py
@@ -28,6 +28,7 @@ BUILT_D8_EXE = os.path.join(REPO_ROOT_DIR, 'third_party', 'v8', 'v8', 'out',
                             'Release', 'd8')
 DOWNLOAD_D8_EXE = os.path.join(REPO_ROOT_DIR, 'out', 'd8')
 DEFAULT_WASM_WAST_EXE = os.path.join(REPO_ROOT_DIR, 'out', 'wasm-wast')
+DEFAULT_WASM_INTERP_EXE = os.path.join(REPO_ROOT_DIR, 'out', 'wasm-interp')
 
 
 if IS_WINDOWS:
@@ -35,6 +36,7 @@ if IS_WINDOWS:
   BUILT_D8_EXE += '.exe'
   DOWNLOAD_D8_EXE += '.exe'
   DEFAULT_WASM_WAST_EXE += '.exe'
+  DEFAULT_WASM_INTERP_EXE += '.exe'
 
 
 def FindExeWithFallback(name, default_exe_list, override_exe=None):
@@ -61,5 +63,9 @@ def GetWasmWastExecutable(override=None):
   return FindExeWithFallback('wasm-wast', [DEFAULT_WASM_WAST_EXE], override)
 
 
+def GetWasmInterpExecutable(override=None):
+  return FindExeWithFallback('wasm-interp', [DEFAULT_WASM_INTERP_EXE], override)
+
+
 def GetD8Executable(override=None):
   return FindExeWithFallback('d8', [BUILT_D8_EXE, DOWNLOAD_D8_EXE], override)
diff --git a/test/run-interp.py b/test/run-interp.py
new file mode 100755
index 00000000..3d860ed5
--- /dev/null
+++ b/test/run-interp.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+#
+# Copyright 2016 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 os
+import subprocess
+import sys
+import tempfile
+
+import find_exe
+from utils import Error
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+def main(args):
+  parser = argparse.ArgumentParser()
+  parser.add_argument('-e', '--executable', metavar='PATH',
+                      help='override sexpr-wasm executable.')
+  parser.add_argument('--wasm-interp-executable', metavar='PATH',
+                      help='override wasm-interp executable.')
+  parser.add_argument('-v', '--verbose', help='print more diagnotic messages.',
+                      action='store_true')
+  parser.add_argument('--use-libc-allocator', action='store_true')
+  parser.add_argument('file', help='test file.')
+  options = parser.parse_args(args)
+
+  sexpr_wasm_exe = find_exe.GetSexprWasmExecutable(options.executable)
+  wasm_interp_exe = find_exe.GetWasmInterpExecutable(
+      options.wasm_interp_executable)
+
+  generated = None
+  try:
+    # Use delete=False because Windows can't open a NamedTemporaryFile until it
+    # is cloesd, but it will be deleted by default if it is closed.
+    generated = tempfile.NamedTemporaryFile(prefix='sexpr-wasm-', delete=False)
+    generated.close()
+    wasm_file = generated.name
+    # First compile the file
+    cmd = [sexpr_wasm_exe, '-o', wasm_file]
+    if options.verbose:
+      cmd.append('-v')
+    if options.use_libc_allocator:
+      cmd.extend(['--use-libc-allocator'])
+    cmd.append(options.file)
+    try:
+      process = subprocess.Popen(cmd, stderr=subprocess.PIPE)
+      _, stderr = process.communicate()
+      if process.returncode != 0:
+        raise Error(stderr)
+    except OSError as e:
+      raise Error(str(e))
+
+    cmd = [wasm_interp_exe, wasm_file]
+    try:
+      process = subprocess.Popen(cmd, stderr=subprocess.PIPE,
+                                 universal_newlines=True)
+      _, stderr = process.communicate()
+      if process.returncode != 0:
+        raise Error(stderr)
+    except OSError as e:
+      raise Error(str(e))
+
+  finally:
+    if generated:
+      os.remove(generated.name)
+
+  return 0
+
+
+if __name__ == '__main__':
+  try:
+    sys.exit(main(sys.argv[1:]))
+  except Error as e:
+    sys.stderr.write(str(e) + '\n')
+    sys.exit(1)
+