#include "wasm.h"
#include "parser.h"
#include "debug.h"
#include "error.h"

#include <unistd.h>
#include <math.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>


#define ERR_STACK_SIZE 16
#define NUM_LOCALS 0xFFFF
#define WASM_PAGE_SIZE 65536
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

static const int MAX_LABELS = 1024;

static int interp_code(struct wasm_interp *interp);
static INLINE int pop_label_checkpoint(struct wasm_interp *interp);

struct expr_parser {
	struct wasm_interp *interp; // optional...
	struct cursor *code;
	struct errors *errs;
	struct cursor *stack; // optional
};

static INLINE int cursor_popval(struct cursor *cur, struct val *val)
{
	return cursor_pop(cur, (unsigned char*)val, sizeof(*val));
}

static const char *valtype_name(enum valtype valtype)
{
	switch (valtype) {
	case val_i32: return "i32";
	case val_i64: return "i64";
	case val_f32: return "f32";
	case val_f64: return "f64";
	case val_ref_null: return "null";
	case val_ref_func: return "func";
	case val_ref_extern: return "extern";
	}

	return "?";
}

static const char *reftype_name(enum reftype reftype) {
	return valtype_name((enum valtype)reftype);
}

static const char *valtype_literal(enum valtype valtype)
{
	switch (valtype) {
	case val_i32: return "";
	case val_i64: return "L";
	case val_f32: return "";
	case val_f64: return "f";
	case val_ref_null: return "null";
	case val_ref_func: return "func";
	case val_ref_extern: return "extern";
	}

	return "?";
}

static INLINE int is_valid_fn_index(struct module *module, u32 ind)
{
	return ind < module->num_funcs;
}

static INLINE struct func *get_fn(struct module *module, u32 ind)
{
	if (unlikely(!is_valid_fn_index(module, ind)))
		return NULL;
	return &module->funcs[ind];
}

u8 *interp_mem_ptr(struct wasm_interp *interp, u32 ptr, int size)
{
	u8 *pos = interp->memory.start + ptr;

	if (ptr == 0) {
		interp_error(interp, "null mem_ptr");
		return NULL;
	}

	if (pos + size >= interp->memory.p) {
		interp_error(interp, "guest invalid mem read: %d > %d",
			pos, interp->memory.p - interp->memory.start);
		return NULL;
	}

	return pos;
}

/*
static INLINE int read_mem(struct wasm_interp *interp, u32 ptr, int size,
		void *dest)
{
	u8 *mem;
	if (!(mem = interp_mem_ptr(interp, ptr, size)))
		return interp_error(interp, "invalid mem pointer");
	memcpy(dest, mem, size);
	return 1;
}

static INLINE int read_mem_u32(struct wasm_interp *interp, u32 ptr, u32 *i)
{
	return read_mem(interp, ptr, sizeof(*i), i);
}

static INLINE int mem_ptr_f32(struct wasm_interp *interp, u32 ptr, float **i)
{
	if (!(*i = (float*)interp_mem_ptr(interp, ptr, sizeof(float))))
		return interp_error(interp, "int memptr");
	return 1;
}

static INLINE int mem_ptr_u32(struct wasm_interp *interp, u32 ptr, u32 **i)
{
	if (!(*i = (u32*)interp_mem_ptr(interp, ptr, sizeof(int))))
		return interp_error(interp, "uint memptr");
	return 1;
}

static INLINE int mem_ptr_u32_arr(struct wasm_interp *interp, u32 ptr, int n, u32 **i)
{
	if (!(*i = (u32*)interp_mem_ptr(interp, ptr, n * sizeof(int))))
		return interp_error(interp, "uint memptr");
	return 1;
}


static INLINE int read_mem_i32(struct wasm_interp *interp, u32 ptr, int *i)
{
	return read_mem(interp, ptr, sizeof(*i), i);
}
 */

static INLINE struct val *get_local(struct wasm_interp *interp, u32 ind)
{
	struct callframe *frame;

	if (unlikely(!(frame = top_callframe(&interp->callframes)))) {
		interp_error(interp, "no callframe?");
		return NULL;
	}

	if (unlikely(ind >= frame->func->num_locals)) {
		interp_error(interp, "local index %d too high for %s:%d (max %d)",
				ind, frame->func->name, frame->func->idx,
				frame->func->num_locals-1);
		return NULL;
	}

	return &frame->locals[ind];
}

int get_var_params(struct wasm_interp *interp, struct val **vals, u32 *num_vals)
{
    struct callframe *frame;

    if (unlikely(!(frame = top_callframe(&interp->callframes))))
        return interp_error(interp, "no callframe?");

    *num_vals = frame->func->functype->params.num_valtypes;
    *vals = frame->locals;

    return 1;
}

int get_params(struct wasm_interp *interp, struct val** vals, u32 num_vals)
{
    u32 nvals;
    if (!get_var_params(interp, vals, &nvals))
        return 0;
        
    if (nvals != num_vals)
        return interp_error(interp, "requested %d params, but there are %d", num_vals, nvals);

    return 1;
}

static INLINE int stack_popval(struct wasm_interp *interp, struct val *val)
{
	return cursor_popval(&interp->stack, val);
}

static INLINE struct val *cursor_topval(struct cursor *stack)
{
	return (struct val *)cursor_top(stack, sizeof(struct val));
}

static INLINE struct val *stack_topval(struct wasm_interp *interp)
{
	return cursor_topval(&interp->stack);
}

static INLINE struct val *stack_top_type(struct wasm_interp *interp,
					 enum valtype type)
{
	struct val *val;
	if (unlikely(!(val = stack_topval(interp)))) {
		interp_error(interp, "pop");
		return NULL;
	}
	if (val->type != type) {
		interp_error(interp,
				"type mismatch: got %s, expected %s",
				valtype_name(val->type),
				valtype_name(type)
				);
		return NULL;
	}
	return val;
}

static INLINE struct val *stack_top_i32(struct wasm_interp *interp)
{
	return stack_top_type(interp, val_i32);
}

static INLINE struct val *stack_top_f32(struct wasm_interp *interp)
{
	return stack_top_type(interp, val_f32);
}

static INLINE struct val *stack_top_f64(struct wasm_interp *interp)
{
	return stack_top_type(interp, val_f64);
}

static INLINE struct val *stack_top_i64(struct wasm_interp *interp)
{
	return stack_top_type(interp, val_i64);
}

static INLINE int cursor_pop_i32(struct cursor *stack, int *i)
{
	struct val val;
	if (unlikely(!cursor_popval(stack, &val)))
		return 0;
	if (unlikely(val.type != val_i32))
		return 0;
	*i = val.num.i32;
	return 1;
}

static INLINE int cursor_pop_i64(struct cursor *stack, int64_t *i)
{
	struct val val;
	if (unlikely(!cursor_popval(stack, &val)))
		return 0;
	if (unlikely(val.type != val_i64))
		return 0;
	*i = val.num.i64;
	return 1;
}


static int is_reftype(enum valtype type)
{
	switch (type) {
	case val_i32:
	case val_i64:
	case val_f32:
	case val_f64:
		return 0;
	case val_ref_null:
	case val_ref_func:
	case val_ref_extern:
		return 1;
	}
	return 0;
}

/*
static INLINE int cursor_pop_ref(struct cursor *stack, struct val *val)
{
	if (!cursor_popval(stack, val)) {
		return 0;
	}
	if (!is_reftype(val->type)) {
		return 0;
	}
	return 1;
}
*/

static INLINE int stack_pop_ref(struct wasm_interp *interp, struct val *val)
{
	if (!cursor_popval(&interp->stack, val)) {
		return interp_error(interp, "no value on stack");
	}
	if (!is_reftype(val->type)) {
		return interp_error(interp, "not a reftype, got %s",
				valtype_name(val->type));
	}
	return 1;
}

static INLINE int stack_pop_i32(struct wasm_interp *interp, int *i)
{
	return cursor_pop_i32(&interp->stack, i);
}

static INLINE int stack_pop_i64(struct wasm_interp *interp, int64_t *i)
{
	return cursor_pop_i64(&interp->stack, i);
}

static INLINE int cursor_pop_valtype(struct cursor *stack, enum valtype type,
		struct val *val)
{
	if (unlikely(!cursor_popval(stack, val))) {
		return 0;
	}

	if (unlikely(val->type != type)) {
		return 0;
	}

	return 1;
}

static INLINE int stack_pop_valtype(struct wasm_interp *interp,
		enum valtype type, struct val *val)
{
	return cursor_pop_valtype(&interp->stack, type, val);
}

static void print_val(struct val *val)
{
	switch (val->type) {
	case val_i32: printf("%d", val->num.i32); break;
	case val_i64: printf("%" PRId64, val->num.i64); break;
	case val_f32: printf("%f", val->num.f32); break;
	case val_f64: printf("%f", val->num.f64); break;

	case val_ref_null:
		      break;
	case val_ref_func:
	case val_ref_extern:
		      printf("%d", val->ref.addr);
		      break;
	}
	printf("%s", valtype_literal(val->type));
}

#ifdef DEBUG
static void print_refval(struct refval *ref, enum reftype reftype)
{
	struct val val;
	val.type = (enum valtype)reftype;
	val.ref = *ref;
	print_val(&val);
}
#endif

static void print_stack(struct cursor *stack)
{
	struct val val;
	int i;
	u8 *p = stack->p;

	if (stack->p == stack->start) {
		return;
	}

	for (i = 0; stack->p > stack->start; i++) {
		cursor_popval(stack, &val);
		printf("[%d] ", i);
		print_val(&val);
		printf("\n");
	}

	stack->p = p;
}

void print_callstack(struct wasm_interp *interp)
{
	int i = 0;
	struct callframe *frame;

	printf("callstack:\n");
	while ((frame = top_callframes(&interp->callframes, i++))) {
		if (!frame->func) {
			printf("??\n");
			continue;
		}
		else {
			printf("%d %s:%d\n", i, frame->func->name, frame->func->idx);
		}
	}
}

static INLINE int cursor_push_i64(struct cursor *stack, s64 i)
{
    struct val val;
    val.type = val_i64;
    val.num.i64 = i;

    return cursor_pushval(stack, &val);
}

static INLINE int cursor_push_f32(struct cursor *stack, float f)
{
    struct val val;
    val.type = val_f32;
    val.num.f32 = f;

    return cursor_pushval(stack, &val);
}

static INLINE int cursor_push_f64(struct cursor *stack, double f)
{
    struct val val;
    val.type = val_f64;
    val.num.f64 = f;

    return cursor_pushval(stack, &val);
}

static INLINE int cursor_push_u64(struct cursor *stack, u64 i)
{
	struct val val;
	val.type = val_i64;
	val.num.u64 = i;

	return cursor_pushval(stack, &val);
}

static INLINE int cursor_push_funcref(struct cursor *stack, int addr)
{
	struct val val;
	val.type = val_ref_func;
	val.ref.addr = addr;
	return cursor_pushval(stack, &val);
}

static INLINE int stack_push_i64(struct wasm_interp *interp, s64 i)
{
	return cursor_push_u64(&interp->stack, (u64)i);
}

/*
static INLINE int stack_push_u64(struct wasm_interp *interp, u64 i)
{
	return cursor_push_u64(&interp->stack, i);
}
 */

static INLINE void make_i32_val(struct val *val, int v)
{
	val->type = val_i32;
	val->num.i32 = v;
}

static INLINE void make_f64_val(struct val *val, double v)
{
	val->type = val_f64;
	val->num.f64 = v;
}

static INLINE void make_f32_val(struct val *val, float v)
{
	val->type = val_f32;
	val->num.f32 = v;
}

static INLINE int stack_pushval(struct wasm_interp *interp, struct val *val)
{
	return cursor_pushval(&interp->stack, val);
}

/*
static int interp_exit(struct wasm_interp *interp)
{
	struct val *vals = NULL;
	if (!get_params(interp, &vals, 1))
		return interp_error(interp, "exit param missing?");
	interp->quitting = 1;
	stack_push_i32(interp, vals[0].num.i32);
	return 0;
}

static int wasi_proc_exit(struct wasm_interp *interp)
{
	return interp_exit(interp);
}

static int wasi_abort(struct wasm_interp *interp)
{
	struct val *params = NULL;

	if (!get_params(interp, &params, 4))
		return interp_error(interp, "exit param missing?");

	printf("abort\n");

	interp->quitting = 1;
	stack_push_i32(interp, 88);

	return 0;
}
 */

static INLINE const char *get_function_name(struct module *module, int fn)
{
	struct func *func = NULL;
	if (unlikely(!(func = get_fn(module, fn)))) {
		return "unknown";
	}
	return func->name;
}

/*
static int wasi_args_sizes_get(struct wasm_interp *interp);
static int wasi_args_get(struct wasm_interp *interp);
static int wasi_fd_write(struct wasm_interp *interp);
static int wasi_fd_close(struct wasm_interp *interp);
static int wasi_environ_sizes_get(struct wasm_interp *interp);
static int wasi_environ_get(struct wasm_interp *interp);
 */

static int parse_instr(struct expr_parser *parser, u8 tag, struct instr *op);

static INLINE int is_valtype(unsigned char byte)
{
	switch ((enum valtype)byte) {
		case val_i32: // i32
		case val_i64: // i64
		case val_f32: // f32
		case val_f64: // f64
		case val_ref_func: // funcref
		case val_ref_null: // null
		case val_ref_extern: // externref
			return 1;
	}

	return 0;
}


/*
static int sizeof_valtype(enum valtype valtype)
{
	switch (valtype) {
	case i32: return 4;
	case f32: return 4;
	case i64: return 8;
	case f64: return 8;
	}

	return 0;
}
*/

static char *instr_name(enum instr_tag tag)
{
	static char unk[6] = {0};

	switch (tag) {
		case i_unreachable: return "unreachable";
		case i_nop: return "nop";
		case i_block: return "block";
		case i_loop: return "loop";
		case i_if: return "if";
		case i_else: return "else";
		case i_end: return "end";
		case i_br: return "br";
		case i_br_if: return "br_if";
		case i_br_table: return "br_table";
		case i_return: return "return";
		case i_call: return "call";
		case i_call_indirect: return "call_indirect";
		case i_drop: return "drop";
		case i_select: return "select";
		case i_local_get: return "local_get";
		case i_local_set: return "local_set";
		case i_local_tee: return "local_tee";
		case i_global_get: return "global_get";
		case i_global_set: return "global_set";
		case i_i32_load: return "i32_load";
		case i_i64_load: return "i64_load";
		case i_f32_load: return "f32_load";
		case i_f64_load: return "f64_load";
		case i_i32_load8_s: return "i32_load8_s";
		case i_i32_load8_u: return "i32_load8_u";
		case i_i32_load16_s: return "i32_load16_s";
		case i_i32_load16_u: return "i32_load16_u";
		case i_i64_load8_s: return "i64_load8_s";
		case i_i64_load8_u: return "i64_load8_u";
		case i_i64_load16_s: return "i64_load16_s";
		case i_i64_load16_u: return "i64_load16_u";
		case i_i64_load32_s: return "i64_load32_s";
		case i_i64_load32_u: return "i64_load32_u";
		case i_i32_store: return "i32_store";
		case i_i64_store: return "i64_store";
		case i_f32_store: return "f32_store";
		case i_f64_store: return "f64_store";
		case i_i32_store8: return "i32_store8";
		case i_i32_store16: return "i32_store16";
		case i_i64_store8: return "i64_store8";
		case i_i64_store16: return "i64_store16";
		case i_i64_store32: return "i64_store32";
		case i_memory_size: return "memory_size";
		case i_memory_grow: return "memory_grow";
		case i_i32_const: return "i32_const";
		case i_i64_const: return "i64_const";
		case i_f32_const: return "f32_const";
		case i_f64_const: return "f64_const";
		case i_i32_eqz: return "i32_eqz";
		case i_i32_eq: return "i32_eq";
		case i_i32_ne: return "i32_ne";
		case i_i32_lt_s: return "i32_lt_s";
		case i_i32_lt_u: return "i32_lt_u";
		case i_i32_gt_s: return "i32_gt_s";
		case i_i32_gt_u: return "i32_gt_u";
		case i_i32_le_s: return "i32_le_s";
		case i_i32_le_u: return "i32_le_u";
		case i_i32_ge_s: return "i32_ge_s";
		case i_i32_ge_u: return "i32_ge_u";
		case i_i64_eqz: return "i64_eqz";
		case i_i64_eq: return "i64_eq";
		case i_i64_ne: return "i64_ne";
		case i_i64_lt_s: return "i64_lt_s";
		case i_i64_lt_u: return "i64_lt_u";
		case i_i64_gt_s: return "i64_gt_s";
		case i_i64_gt_u: return "i64_gt_u";
		case i_i64_le_s: return "i64_le_s";
		case i_i64_le_u: return "i64_le_u";
		case i_i64_ge_s: return "i64_ge_s";
		case i_i64_ge_u: return "i64_ge_u";
		case i_f32_eq: return "f32_eq";
		case i_f32_ne: return "f32_ne";
		case i_f32_lt: return "f32_lt";
		case i_f32_gt: return "f32_gt";
		case i_f32_le: return "f32_le";
		case i_f32_ge: return "f32_ge";
		case i_f64_eq: return "f64_eq";
		case i_f64_ne: return "f64_ne";
		case i_f64_lt: return "f64_lt";
		case i_f64_gt: return "f64_gt";
		case i_f64_le: return "f64_le";
		case i_f64_ge: return "f64_ge";
		case i_i32_clz: return "i32_clz";
		case i_i32_ctz: return "i32_ctz";
		case i_i32_popcnt: return "i32_popcnt";
		case i_i32_add: return "i32_add";
		case i_i32_sub: return "i32_sub";
		case i_i32_mul: return "i32_mul";
		case i_i32_div_s: return "i32_div_s";
		case i_i32_div_u: return "i32_div_u";
		case i_i32_rem_s: return "i32_rem_s";
		case i_i32_rem_u: return "i32_rem_u";
		case i_i32_and: return "i32_and";
		case i_i32_or: return "i32_or";
		case i_i32_xor: return "i32_xor";
		case i_i32_shl: return "i32_shl";
		case i_i32_shr_s: return "i32_shr_s";
		case i_i32_shr_u: return "i32_shr_u";
		case i_i32_rotl: return "i32_rotl";
		case i_i32_rotr: return "i32_rotr";
		case i_i64_clz: return "i64_clz";
		case i_i64_ctz: return "i64_ctz";
		case i_i64_popcnt: return "i64_popcnt";
		case i_i64_add: return "i64_add";
		case i_i64_sub: return "i64_sub";
		case i_i64_mul: return "i64_mul";
		case i_i64_div_s: return "i64_div_s";
		case i_i64_div_u: return "i64_div_u";
		case i_i64_rem_s: return "i64_rem_s";
		case i_i64_rem_u: return "i64_rem_u";
		case i_i64_and: return "i64_and";
		case i_i64_or: return "i64_or";
		case i_i64_xor: return "i64_xor";
		case i_i64_shl: return "i64_shl";
		case i_i64_shr_s: return "i64_shr_s";
		case i_i64_shr_u: return "i64_shr_u";
		case i_i64_rotl: return "i64_rotl";
		case i_i64_rotr: return "i64_rotr";
		case i_f32_abs: return "f32_abs";
		case i_f32_neg: return "f32_neg";
		case i_f32_ceil: return "f32_ceil";
		case i_f32_floor: return "f32_floor";
		case i_f32_trunc: return "f32_trunc";
		case i_f32_nearest: return "f32_nearest";
		case i_f32_sqrt: return "f32_sqrt";
		case i_f32_add: return "f32_add";
		case i_f32_sub: return "f32_sub";
		case i_f32_mul: return "f32_mul";
		case i_f32_div: return "f32_div";
		case i_f32_min: return "f32_min";
		case i_f32_max: return "f32_max";
		case i_f32_copysign: return "f32_copysign";
		case i_f64_abs: return "f64_abs";
		case i_f64_neg: return "f64_neg";
		case i_f64_ceil: return "f64_ceil";
		case i_f64_floor: return "f64_floor";
		case i_f64_trunc: return "f64_trunc";
		case i_f64_nearest: return "f64_nearest";
		case i_f64_sqrt: return "f64_sqrt";
		case i_f64_add: return "f64_add";
		case i_f64_sub: return "f64_sub";
		case i_f64_mul: return "f64_mul";
		case i_f64_div: return "f64_div";
		case i_f64_min: return "f64_min";
		case i_f64_max: return "f64_max";
		case i_f64_copysign: return "f64_copysign";
		case i_i32_wrap_i64: return "i32_wrap_i64";
		case i_i32_trunc_f32_s: return "i32_trunc_f32_s";
		case i_i32_trunc_f32_u: return "i32_trunc_f32_u";
		case i_i32_trunc_f64_s: return "i32_trunc_f64_s";
		case i_i32_trunc_f64_u: return "i32_trunc_f64_u";
		case i_i64_extend_i32_s: return "i64_extend_i32_s";
		case i_i64_extend_i32_u: return "i64_extend_i32_u";
		case i_i64_trunc_f32_s: return "i64_trunc_f32_s";
		case i_i64_trunc_f32_u: return "i64_trunc_f32_u";
		case i_i64_trunc_f64_s: return "i64_trunc_f64_s";
		case i_i64_trunc_f64_u: return "i64_trunc_f64_u";
		case i_f32_convert_i32_s: return "f32_convert_i32_s";
		case i_f32_convert_i32_u: return "f32_convert_i32_u";
		case i_f32_convert_i64_s: return "f32_convert_i64_s";
		case i_f32_convert_i64_u: return "f32_convert_i64_u";
		case i_f32_demote_f64: return "f32_demote_f64";
		case i_f64_convert_i32_s: return "f64_convert_i32_s";
		case i_f64_convert_i32_u: return "f64_convert_i32_u";
		case i_f64_convert_i64_s: return "f64_convert_i64_s";
		case i_f64_convert_i64_u: return "f64_convert_i64_u";
		case i_f64_promote_f32: return "f64_promote_f32";
		case i_i32_reinterpret_f32: return "i32_reinterpret_f32";
		case i_i64_reinterpret_f64: return "i64_reinterpret_f64";
		case i_f32_reinterpret_i32: return "f32_reinterpret_i32";
		case i_f64_reinterpret_i64: return "f64_reinterpret_i64";
		case i_i32_extend8_s: return "i32_extend8_s";
		case i_i32_extend16_s: return "i32_extend16_s";
		case i_i64_extend8_s: return "i64_extend8_s";
		case i_i64_extend16_s: return "i64_extend16_s";
		case i_i64_extend32_s: return "i64_extend32_s";
		case i_ref_null: return "ref_null";
		case i_ref_func: return "ref_func";
		case i_ref_is_null: return "ref_is_null";
		case i_bulk_op: return "bulk_op";
		case i_table_get: return "table_get";
		case i_table_set: return "table_set";
		case i_selects: return "selects";
	}

	snprintf(unk, sizeof(unk), "0x%02x", tag);
	return unk;
}

static INLINE int was_name_section_parsed(struct module *module,
		enum name_subsection_tag subsection)
{
	if (!was_section_parsed(module, section_name)) {
		return 0;
	}

    return module->name_section.parsed & (1 << subsection);
}

//static int callframe_cnt = 0;

static INLINE int cursor_push_callframe(struct cursor *cur, struct callframe *frame)
{
	//debug("pushing callframe %d fn:%d\n", ++callframe_cnt, frame->fn);
	return cursor_push(cur, (u8*)frame, sizeof(*frame));
}

static INLINE int count_resolvers(struct wasm_interp *interp)
{
	return (int)cursor_count(&interp->resolver_stack, sizeof(struct resolver));
}

static INLINE int push_callframe(struct wasm_interp *interp, struct callframe *frame)
{
	u32 offset;

	offset = count_resolvers(interp);
	/* push label resolver offsets, used to keep track of per-func resolvers */
	/* TODO: maybe move this data to struct func? */
	if (unlikely(!cursor_push_int(&interp->resolver_offsets, offset)))
		return interp_error(interp, "push resolver offset");

	return cursor_push_callframe(&interp->callframes, frame);
}

static INLINE int cursor_drop_callframe(struct cursor *cur)
{
	//debug("dropping callframe %d fn:%d\n", callframe_cnt--, top_callframe(cur)->fn);
	return cursor_drop(cur, sizeof(struct callframe));
}

static INLINE int cursor_dropval(struct cursor *stack)
{
	return cursor_drop(stack, sizeof(struct val));
}

static INLINE int cursor_popint(struct cursor *cur, int *i)
{
	return cursor_pop(cur, (u8 *)i, sizeof(int));
}


void print_error_backtrace(struct errors *errors)
{
	struct cursor errs;
	struct error err;

	copy_cursor(&errors->cur, &errs);
	errs.p = errs.start;

	while (errs.p < errors->cur.p) {
		if (!cursor_pull_error(&errs, &err)) {
			printf("backtrace: couldn't pull error\n");
			return;
		}
		printf("%08x:%s\n", err.pos, err.msg);
	}
}

static void _functype_str(struct functype *ft, struct cursor *buf)
{
	u32 i;

	cursor_push_str(buf, "(");

	for (i = 0; i < ft->params.num_valtypes; i++) {
		cursor_push_str(buf, valtype_name(ft->params.valtypes[i]));

		if (i != ft->params.num_valtypes-1) {
			cursor_push_str(buf, ", ");
		}
	}

	cursor_push_str(buf, ") -> (");

	for (i = 0; i < ft->result.num_valtypes; i++) {
		cursor_push_str(buf, valtype_name(ft->result.valtypes[i]));

		if (i != ft->result.num_valtypes-1) {
			cursor_push_str(buf, ", ");
		}
	}

	cursor_push_c_str(buf, ")");
}

static const char *functype_str(struct functype *ft, char *buf, int buflen)
{
	struct cursor cur;
	if (buflen == 0)
		return "";

	buf[buflen-1] = 0;
	make_cursor((u8*)buf, (u8*)buf + buflen-1, &cur);

	_functype_str(ft, &cur);

	return (const char*)buf;
}

static void print_functype(struct functype *ft)
{
	static char buf[0xFF];
	printf("%s\n", functype_str(ft, buf, sizeof(buf)));
}

static void print_type_section(struct typesec *typesec)
{
	u32 i;
	printf("%d functypes:\n", typesec->num_functypes);
	for (i = 0; i < typesec->num_functypes; i++) {
		printf("    ");
		print_functype(&typesec->functypes[i]);
	}
}

static void print_func_section(struct funcsec *funcsec)
{
	printf("%d functions\n", funcsec->num_indices);
	/*
	printf("    ");
	for (i = 0; i < funcsec->num_indices; i++) {
		printf("%d ", funcsec->type_indices[i]);
	}
	printf("\n");
	*/
}

__attribute__((unused))
static const char *exportdesc_name(enum exportdesc desc)
{
	switch (desc) {
		case export_func: return "function";
		case export_table: return "table";
		case export_mem: return "memory";
		case export_global: return "global";
	}

	return "unknown";
}

static void print_import(struct import *import)
{
	(void)import;
	printf("%s %s\n", import->module_name, import->name);
}

static void print_import_section(struct importsec *importsec)
{
	u32 i;
	printf("%d imports:\n", importsec->num_imports);
	for (i = 0; i < importsec->num_imports; i++) {
		printf("    ");
		print_import(&importsec->imports[i]);
	}
}

static void print_limits(struct limits *limits)
{
	switch (limits->type) {
	case limit_min:
		printf("%d", limits->min);
		break;
	case limit_min_max:
		printf("%d-%d", limits->min, limits->max);
		break;
	}
}

static void print_memory_section(struct memsec *memory)
{
	u32 i;
	struct limits *mem;

	printf("%d memory:\n", memory->num_mems);
	for (i = 0; i < memory->num_mems; i++) {
		mem = &memory->mems[i];
		printf("    ");
		print_limits(mem);
		printf("\n");
	}
}

static void print_table_section(struct tablesec *section)
{
	u32 i;
	struct table *table;

	printf("%d tables:\n", section->num_tables);
	for (i = 0; i < section->num_tables; i++) {
		table = &section->tables[i];
		printf("    ");
		printf("%s: ", reftype_name(table->reftype));
		print_limits(&table->limits);
		printf("\n");
	}
}

static int count_imports(struct module *module, enum import_type *typ)
{
	u32 i, count = 0;
	struct import *import;
	struct importsec *imports;

	if (!was_section_parsed(module, section_import))
		return 0;

	imports = &module->import_section;

	if (typ == NULL)
		return imports->num_imports;

	for (i = 0; i < imports->num_imports; i++) {
		import = &imports->imports[i];
		if (import->desc.type == *typ) {
			count++;
		}
	}

	return count;
}

static INLINE int count_imported_functions(struct module *module)
{
	enum import_type typ = import_func;
	return count_imports(module, &typ);
}

static void print_element_section(struct elemsec *section)
{
	printf("%d elements\n", section->num_elements);
}

static void print_start_section(struct module *module)
{
	u32 fn = module->start_section.start_fn;
	printf("start function: %d <%s>\n", fn, get_function_name(module, fn));
}

static void print_export_section(struct exportsec *exportsec)
{
	u32 i;
	printf("%d exports:\n", exportsec->num_exports);
	for (i = 0; i < exportsec->num_exports; i++) {
		printf("    ");
		printf("%s %s %d\n", exportdesc_name(exportsec->exports[i].desc),
				exportsec->exports[i].name,
				exportsec->exports[i].index);
	}
}

/*
static void print_local(struct local *local)
{
	debug("%d %s\n", local->n, valtype_name(local->valtype));
}

static void print_func(struct wasm_func *func)
{
	int i;

	debug("func locals (%d): \n", func->num_locals);
	for (i = 0; i < func->num_locals; i++) {
		print_local(&func->locals[i]);
	}
	debug("%d bytes of code\n", func->code_len);
}
*/

static void print_global_section(struct globalsec *section)
{
	printf("%d globals\n", section->num_globals);
}


static void print_code_section(struct codesec *codesec)
{
	printf("%d code segments\n", codesec->num_funcs);
	/*
	for (i = 0; i < codesec->num_funcs; i++) {
		print_func(&codesec->funcs[i]);
	}
	*/
}

static void print_data_section(struct datasec *section)
{
	printf("%d data segments\n", section->num_datas);
}

static void print_custom_section(struct customsec *section)
{
	printf("custom (%s) %d bytes\n", section->name, section->data_len);
}

static void print_section(struct module *module, enum section_tag section)
{
	u32 i;

	switch (section) {
	case section_custom:
		for (i = 0; i < module->custom_sections; i++) {
			print_custom_section(&module->custom_section[i]);
		}
		break;
	case section_type:
		print_type_section(&module->type_section);
		break;
	case section_import:
		print_import_section(&module->import_section);
		break;
	case section_function:
		print_func_section(&module->func_section);
		break;
	case section_table:
		print_table_section(&module->table_section);
		break;
	case section_memory:
		print_memory_section(&module->memory_section);
		break;
	case section_global:
		print_global_section(&module->global_section);
		break;
	case section_export:
		print_export_section(&module->export_section);
		break;
	case section_start:
		print_start_section(module);
		break;
	case section_element:
		print_element_section(&module->element_section);
		break;
	case section_code:
		print_code_section(&module->code_section);
		break;
	case section_data:
		print_data_section(&module->data_section);
		break;
	case section_data_count:
		printf("data count %d\n", module->data_section.num_datas);
		break;
	case section_name:
		printf("todo: print name section\n");
		break;
	case num_sections:
		assert(0);
		break;
	}
}

static void print_module(struct module *module)
{
	u32 i;
	enum section_tag section;

	for (i = 0; i < num_sections; i++) {
		section = (enum section_tag)i;
		if (was_section_parsed(module, section)) {
			print_section(module, section);
		}
	}
}


static int leb128_write(struct cursor *write, unsigned int value)
{
	unsigned char byte;
	while (1) {
		byte = value & 0x7F;
		value >>= 7;
		if (value == 0) {
			if (!cursor_push_byte(write, byte))
				return 0;
			return 1;
		} else {
			if (!cursor_push_byte(write, byte | 0x80))
				return 0;
		}
	}
}

#define BYTE_AT(type, i, shift) (((type)(p[i]) & 0x7f) << (shift))
#define LEB128_1(type) (BYTE_AT(type, 0, 0))
#define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type))
#define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type))
#define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type))
#define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type))

static inline int shiftmask32(u32 val)
{
	return val & 31;
}

static inline int shiftmask64(u64 val)
{
	return val & 63;
}


static INLINE int parse_i64(struct cursor *read, uint64_t *val)
{
	u8 shift;
	u8 byte;

	*val = 0;
	shift = 0;

	do {
		if (!pull_byte(read, &byte))
			return 0;
		*val |= (byte & 0x7FULL) << shift;
		shift += 7;
	} while ((byte & 0x80) != 0);

	/* sign bit of byte is second high-order bit (0x40) */
	if ((shift < 64) && (byte & 0x40))
		*val |= (0xFFFFFFFFFFFFFFFF << shift);

	return 1;
}

static INLINE int uleb128_read(struct cursor *read, unsigned int *val)
{
	unsigned int shift = 0;
	u8 byte;
	*val = 0;

	for (;;) {
		if (!pull_byte(read, &byte))
			return 0;

		*val |= (0x7F & byte) << shift;

		if ((0x80 & byte) == 0)
			break;

		shift += 7;
	}

	return 1;
}

static INLINE int sleb128_read(struct cursor *read, signed int *val)
{
	int shift;
	u8 byte;

	*val = 0;
	shift = 0;

	do {
		if (!pull_byte(read, &byte))
			return 0;
		*val |= ((byte & 0x7F) << shift);
		shift += 7;
	} while ((byte & 0x80) != 0);

	/* sign bit of byte is second high-order bit (0x40) */
	if ((shift < 32) && (byte & 0x40))
		*val |= (0xFFFFFFFF << shift);

	return 1;
}

/*
static INLINE int uleb128_read(struct cursor *read, unsigned int *val)
{
	unsigned char p[6] = {0};
	*val = 0;

	if (pull_byte(read, &p[0]) && (p[0] & 0x80) == 0) {
		*val = LEB128_1(unsigned int);
		if (p[0] == 0x7F)
			assert((int)*val == -1);
		return 1;
	} else if (pull_byte(read, &p[1]) && (p[1] & 0x80) == 0) {
		*val = LEB128_2(unsigned int);
		return 2;
	} else if (pull_byte(read, &p[2]) && (p[2] & 0x80) == 0) {
		*val = LEB128_3(unsigned int);
		return 3;
	} else if (pull_byte(read, &p[3]) && (p[3] & 0x80) == 0) {
		*val = LEB128_4(unsigned int);
		return 4;
	} else if (pull_byte(read, &p[4]) && (p[4] & 0x80) == 0) {
		if (!(p[4] & 0xF0)) {
			*val = LEB128_5(unsigned int);
			return 5;
		}
		//printf("%02X & 0xF0\n", p[4] & 0xF0);
	}

	return 0;
}
*/

static INLINE int parse_int(struct cursor *read, int *val)
{
	return sleb128_read(read, val);
}


static INLINE int parse_u32(struct cursor *read, u32 *val)
{
	return uleb128_read(read, val);
}

static INLINE int read_f32(struct cursor *read, float *val)
{
	return cursor_pull(read, (u8*)val, 4);
}

static INLINE int read_f64(struct cursor *read, double *val)
{
	return cursor_pull(read, (u8*)val, 8);
}

static int parse_section_tag(struct cursor *cur, enum section_tag *section)
{
	unsigned char byte;
	unsigned char *start;
	assert(section);

	start = cur->p;

	if (!pull_byte(cur, &byte)) {
		return 0;
	}

	if (byte >= num_sections) {
		cur->p = start;
		return 0;
	}

	*section = (enum section_tag)byte;
	return 1;
}

static int parse_valtype(struct wasm_parser *p, enum valtype *valtype)
{
	unsigned char *start;

	start = p->cur.p;

	if (unlikely(!pull_byte(&p->cur, (unsigned char*)valtype))) {
		return parse_err(p, "valtype tag oob");
	}

	if (unlikely(!is_valtype((unsigned char)*valtype))) {
		//cursor_print_around(&p->cur, 10);
		p->cur.p = start;
		return parse_err(p, "0x%02x is not a valid valtype tag", *valtype);
	}

	return 1;
}

static int parse_result_type(struct wasm_parser *p, struct resulttype *rt)
{
	u32 i, elems;
	enum valtype valtype;
	unsigned char *start;

	rt->num_valtypes = 0;
	rt->valtypes = 0;
	start = p->mem.p;

	if (unlikely(!parse_u32(&p->cur, &elems))) {
		parse_err(p, "vec len");
		return 0;
	}

	for (i = 0; i < elems; i++)
	{
		if (unlikely(!parse_valtype(p, &valtype))) {
			parse_err(p, "valtype #%d", i);
			p->mem.p = start;
			return 0;
		}

		if (unlikely(!cursor_push_byte(&p->mem, (unsigned char)valtype))) {
			parse_err(p, "valtype push data OOM #%d", i);
			p->mem.p = start;
			return 0;
		}
	}

	rt->num_valtypes = elems;
	rt->valtypes = start;

	return 1;
}


static int parse_func_type(struct wasm_parser *p, struct functype *func)
{
	if (unlikely(!consume_byte(&p->cur, FUNC_TYPE_TAG))) {
		parse_err(p, "type tag");
		return 0;
	}

	if (unlikely(!parse_result_type(p, &func->params))) {
		parse_err(p, "params");
		return 0;
	}

	if (unlikely(!parse_result_type(p, &func->result))) {
		parse_err(p, "result");
		return 0;
	}

	return 1;
}

static int parse_name(struct wasm_parser *p, const char **name)
{
	u32 bytes;
	if (unlikely(!parse_u32(&p->cur, &bytes))) {
		parse_err(p, "name len");
		return 0;
	}

	if (unlikely(!pull_data_into_cursor(&p->cur, &p->mem, (unsigned char**)name,
				bytes))) {
		parse_err(p, "name string");
		return 0;
	}

	if (unlikely(!cursor_push_byte(&p->mem, 0))) {
		parse_err(p, "name null byte");
		return 0;
	}

	return 1;
}

static INLINE int is_valid_name_subsection(u8 tag)
{
	return tag < num_name_subsections;
}

static int parse_export_desc(struct wasm_parser *p, enum exportdesc *desc)
{
	unsigned char byte;

	if (!pull_byte(&p->cur, &byte)) {
		parse_err(p, "export desc byte eof");
		return 0;
	}

	switch((enum exportdesc)byte) {
	case export_func:
	case export_table:
	case export_mem:
	case export_global:
		*desc = (enum exportdesc)byte;
		return 1;
	}

	parse_err(p, "invalid tag: %x", byte);
	return 0;
}

static int parse_export(struct wasm_parser *p, struct wexport *export)
{
	if (!parse_name(p, &export->name)) {
		parse_err(p, "export name");
		return 0;
	}

	if (!parse_export_desc(p, &export->desc)) {
		parse_err(p, "export desc");
		return 0;
	}

	if (!parse_u32(&p->cur, &export->index)) {
		parse_err(p, "export index");
		return 0;
	}

	return 1;
}

static int parse_local_def(struct wasm_parser *p, struct local_def *def)
{
	if (unlikely(!parse_u32(&p->cur, &def->num_types))) {
		debug("fail parse local def\n");
		return parse_err(p, "n");
	}

	if (unlikely(!parse_valtype(p, &def->type))) {
		debug("fail parse valtype\n");
		return parse_err(p, "valtype");
	}

	return 1;
}

static int parse_vector(struct wasm_parser *p, int item_size,
			u32 *elems, void **items)
{
	if (!parse_u32(&p->cur, elems)) {
		return parse_err(p, "len");
	}

	*items = cursor_alloc(&p->mem, *elems * item_size);

	if (*items == NULL) {
		parse_err(p, "vector alloc oom. item_size:%d elems:%d", item_size, *elems);
		return 0;
	}

	return 1;
}

static int parse_nameassoc(struct wasm_parser *p, struct nameassoc *assoc)
{
	if (!parse_u32(&p->cur, &assoc->index))
		return parse_err(p, "index");

	if (!parse_name(p, &assoc->name))
		return parse_err(p, "name");

	//debug("parsed nameassoc %d %s\n", assoc->index, assoc->name);

	return 1;
}

static int parse_namemap(struct wasm_parser *p, struct namemap *map)
{
	u32 i;

	if (!parse_vector(p, sizeof(struct nameassoc), &map->num_names,
			  (void**)&map->names)) {
		return parse_err(p, "parse funcmap vec");
	}

	for (i = 0; i < map->num_names; i++) {
		if (!parse_nameassoc(p, &map->names[i])) {
			return parse_err(p, "name assoc %d/%d", i+1,
					 map->num_names);
		}
	}

	return 1;
}

static int parse_name_subsection(struct wasm_parser *p, struct namesec *sec, u32 *size)
{
	u8 tag;
	u8 *start = p->cur.p;

	if (!pull_byte(&p->cur, &tag))
		return parse_err(p, "name subsection tag oob?");

	if (!is_valid_name_subsection(tag))
		return parse_err(p, "invalid subsection tag 0x%02x", tag);

	if (!parse_u32(&p->cur, size))
		return parse_err(p, "subsection size");

	// include tag and size in size
	*size += p->cur.p - start;

	switch((enum name_subsection_tag)tag) {
	case name_subsection_module:
		if (!parse_name(p, &sec->module_name))
			return parse_err(p, "parse module name");
		sec->parsed |= 1 << name_subsection_module;
		return 1;

	case name_subsection_funcs:
		if (!parse_namemap(p, &sec->func_names))
			return parse_err(p, "func namemap");
		sec->parsed |= 1 << name_subsection_funcs;
		return 1;

	case name_subsection_locals:
		debug("TODO: parse local name subsection\n");
		return 1;

	case num_name_subsections:
		return parse_err(p, "impossibru");
	}

	return parse_err(p, "unknown name subsection: 0x%02x", tag);

}

static int parse_name_section(struct wasm_parser *p, struct namesec *sec,
		struct customsec *customsec)
{
	int i;
	u32 size, subsection_size;

	subsection_size = 0;
	size = 0;
	i = 0;

	for (; i < 3; i++) {
		if (size == customsec->data_len) {
			break;
		} else if (size > customsec->data_len) {
			return parse_err(p, "parse_name_section did not parse"
				"the correct number of bytes. It parsed %d bytes"
				" but %d was expected.",
				size, customsec->data_len);
		}

		if (!parse_name_subsection(p, sec, &subsection_size))
			return parse_err(p, "name subsection %d", i);

		size += subsection_size;
	}

	p->module.parsed |= (1 << section_name);

	return 1;
}


static int parse_func(struct wasm_parser *p, struct wasm_func *func)
{
	struct local_def *defs;
	u32 i, size;
	u8 *start;

	if (!parse_u32(&p->cur, &size)) {
		return parse_err(p, "code size");
	}

	start = p->cur.p;
	defs = (struct local_def*)p->mem.p;

	if (!parse_u32(&p->cur, &func->num_local_defs))
		return parse_err(p, "read locals vec");

	if (!cursor_alloc(&p->mem, sizeof(*defs) * func->num_local_defs))
		return parse_err(p, "oom alloc param locals");

	if (p->cur.p > p->cur.end)
		return parse_err(p, "corrupt functype?");

	for (i = 0; i < func->num_local_defs; i++) {
		if (!parse_local_def(p, &defs[i])) {
			return parse_err(p, "local #%d", i);
		}
	}

	func->local_defs = defs;
    func->code.code_len = (int)(size - (p->cur.p - start));

	if (!pull_data_into_cursor(&p->cur, &p->mem, &func->code.code,
				func->code.code_len)) {
		return parse_err(p, "code oom");
	}

	if (!(func->code.code[func->code.code_len-1] == i_end)) {
		return parse_err(p, "no end tag (corruption?)");
	}

	return 1;
}

static INLINE int count_internal_functions(struct module *module)
{
	return !was_section_parsed(module, section_code) ? 0 :
		module->code_section.num_funcs;
}


static int parse_code_section(struct wasm_parser *p, struct codesec *code_section)
{
	struct wasm_func *funcs;
	u32 i;

	if (!parse_vector(p, sizeof(*funcs), &code_section->num_funcs,
			  (void**)&funcs)) {
		return parse_err(p, "funcs");
	}

	for (i = 0; i < code_section->num_funcs; i++) {
		if (!parse_func(p, &funcs[i])) {
			return parse_err(p, "func #%d", i);
		}
	}

	code_section->funcs = funcs;

	return 1;
}

static int is_valid_reftype(unsigned char reftype)
{
	switch ((enum reftype)reftype) {
		case funcref: return 1;
		case externref: return 1;
	}
	return 0;
}

static int parse_reftype(struct wasm_parser *p, enum reftype *reftype)
{
	u8 tag;

	if (!pull_byte(&p->cur, &tag)) {
		parse_err(p, "reftype");
		return 0;
	}

	if (!is_valid_reftype(tag)) {
		//cursor_print_around(&p->cur, 10);
		parse_err(p, "invalid reftype: 0x%02x", tag);
		return 0;
	}

	*reftype = (enum reftype)tag;

	return 1;
}


static int parse_export_section(struct wasm_parser *p,
		struct exportsec *export_section)
{
	struct wexport *exports;
	u32 elems, i;

	if (!parse_vector(p, sizeof(*exports), &elems, (void**)&exports)) {
		parse_err(p, "vector");
		return 0;
	}

	for (i = 0; i < elems; i++) {
		if (!parse_export(p, &exports[i])) {
			parse_err(p, "export #%d", i);
			return 0;
		}
	}

	export_section->num_exports = elems;
	export_section->exports = exports;

	return 1;
}

static int parse_limits(struct wasm_parser *p, struct limits *limits)
{
	unsigned char tag;
	if (!pull_byte(&p->cur, &tag)) {
		return parse_err(p, "oob");
	}

	if (tag != limit_min && tag != limit_min_max) {
		return parse_err(p, "invalid tag %02x", tag);
	}

	if (!parse_u32(&p->cur, &limits->min)) {
		return parse_err(p, "min");
	}

	if (tag == limit_min)
		return 1;

	if (!parse_u32(&p->cur, &limits->max)) {
		return parse_err(p, "max");
	}

	return 1;
}

static int parse_table(struct wasm_parser *p, struct table *table)
{
	if (!parse_reftype(p, &table->reftype)) {
		return parse_err(p, "reftype");
	}

	if (!parse_limits(p, &table->limits)) {
		return parse_err(p, "limits");
	}

	return 1;
}

static int parse_mut(struct wasm_parser *p, enum mut *mut)
{
	if (consume_byte(&p->cur, mut_const)) {
		*mut = mut_const;
		return 1;
	}

	if (consume_byte(&p->cur, mut_var)) {
		*mut = mut_var;
		return 1;
	}

	return parse_err(p, "unknown mut %02x", *p->cur.p);
}

static int parse_globaltype(struct wasm_parser *p, struct globaltype *g)
{
	if (!parse_valtype(p, &g->valtype)) {
		return parse_err(p, "valtype");
	}

	return parse_mut(p, &g->mut);
}

static INLINE void make_expr_parser(struct errors *errs, struct cursor *code,
		struct expr_parser *p)
{
	p->interp = NULL;
	p->code = code;
	p->errs = errs;
	p->stack = NULL;
}

/*
static void print_code(u8 *code, int code_len)
{
	struct cursor c;
	struct expr_parser parser;
	struct errors errs;
	struct instr op;
	u8 tag;

	errs.enabled = 0;

	make_expr_parser(&errs, &c, &parser);
	make_cursor(code, code + code_len, &c);

	for (;;) {
		if (!pull_byte(&c, &tag)) {
			break;
		}

		printf("%s ", instr_name(tag));

		if (!parse_instr(&parser, tag, &op)) {
			break;
		}
	}

	printf("\n");
}
*/

static INLINE int is_const_instr(u8 tag)
{
	switch ((enum const_instr)tag) {
	case ci_global_get:
	case ci_ref_null:
	case ci_ref_func:
	case ci_const_i32:
	case ci_const_i64:
	case ci_const_f32:
	case ci_end:
	case ci_const_f64:
		return 1;
	}
	return 0;
}

static INLINE int cursor_push_nullval(struct cursor *stack)
{
	struct val val;
	val.type = val_ref_null;
	return cursor_pushval(stack, &val);
}

static INLINE const char *bulk_op_name(struct bulk_op *op)
{
	switch (op->tag) {
	case i_memory_fill: return "memory.fill";
	case i_memory_copy: return "memory.copy";
	case i_table_init:  return "table.init";
	case i_elem_drop:   return "elem.drop";
	case i_table_copy:  return "table.copy";
	case i_table_grow:  return "table.grow";
	case i_table_size:  return "table.size";
	case i_table_fill:  return "table.fill";
	}

	return "?";
}

static const char *show_instr(struct instr *instr)
{
	struct cursor buf;
	static char buffer[64];
	static char tmp[128];
	int len, i;

	buffer[sizeof(buffer)-1] = 0;
	make_cursor((u8*)buffer, (u8*)buffer + sizeof(buffer) - 1, &buf);

	cursor_push_str(&buf, instr_name(instr->tag));
	len = (int)(buf.p - buf.start);

	for (i = 0; i < 14-len; i++)
		cursor_push_byte(&buf, ' ');

	switch (instr->tag) {
		// two-byte instrs
		case i_memory_size:
		case i_memory_grow:
			sprintf(tmp, "0x%02x", instr->memidx);
			cursor_push_str(&buf, tmp);
			break;

		case i_block:
		case i_loop:
		case i_if:
			break;

		case i_else:
		case i_end:
			break;

		case i_call:
		case i_local_get:
		case i_local_set:
		case i_local_tee:
		case i_global_get:
		case i_global_set:
		case i_br:
		case i_br_if:
		case i_i32_const:
		case i_ref_func:
		case i_table_set:
		case i_table_get:
			sprintf(tmp, "%d", instr->i32);
			cursor_push_str(&buf, tmp);
			break;

		case i_i64_const:
			sprintf(tmp, "%" PRId64, instr->i64);
			cursor_push_str(&buf, tmp);
			break;

		case i_ref_null:
			sprintf(tmp, "%s", reftype_name(instr->reftype));
			cursor_push_str(&buf, tmp);
			break;


		case i_i32_load:
		case i_i64_load:
		case i_f32_load:
		case i_f64_load:
		case i_i32_load8_s:
		case i_i32_load8_u:
		case i_i32_load16_s:
		case i_i32_load16_u:
		case i_i64_load8_s:
		case i_i64_load8_u:
		case i_i64_load16_s:
		case i_i64_load16_u:
		case i_i64_load32_s:
		case i_i64_load32_u:
		case i_i32_store:
		case i_i64_store:
		case i_f32_store:
		case i_f64_store:
		case i_i32_store8:
		case i_i32_store16:
		case i_i64_store8:
		case i_i64_store16:
		case i_i64_store32:
			sprintf(tmp, "%d %d", instr->memarg.offset, instr->memarg.align);
			cursor_push_str(&buf, tmp);
			break;

		case i_selects:
			break;

		case i_br_table:
			break;

		case i_call_indirect:
			sprintf(tmp, "%d %d", instr->call_indirect.typeidx,
					instr->call_indirect.tableidx);
			cursor_push_str(&buf, tmp);
			break;

		case i_f32_const:
			sprintf(tmp, "%f", instr->f32);
			cursor_push_str(&buf, tmp);
			break;

		case i_f64_const:
			sprintf(tmp, "%f", instr->f64);
			cursor_push_str(&buf, tmp);
			break;

		// single-tag ops
		case i_unreachable:
		case i_nop:
		case i_return:
		case i_drop:
		case i_select:
		case i_i32_eqz:
		case i_i32_eq:
		case i_i32_ne:
		case i_i32_lt_s:
		case i_i32_lt_u:
		case i_i32_gt_s:
		case i_i32_gt_u:
		case i_i32_le_s:
		case i_i32_le_u:
		case i_i32_ge_s:
		case i_i32_ge_u:
		case i_i64_eqz:
		case i_i64_eq:
		case i_i64_ne:
		case i_i64_lt_s:
		case i_i64_lt_u:
		case i_i64_gt_s:
		case i_i64_gt_u:
		case i_i64_le_s:
		case i_i64_le_u:
		case i_i64_ge_s:
		case i_i64_ge_u:
		case i_f32_eq:
		case i_f32_ne:
		case i_f32_lt:
		case i_f32_gt:
		case i_f32_le:
		case i_f32_ge:
		case i_f64_eq:
		case i_f64_ne:
		case i_f64_lt:
		case i_f64_gt:
		case i_f64_le:
		case i_f64_ge:
		case i_i32_clz:
		case i_i32_ctz:
		case i_i32_popcnt:
		case i_i32_add:
		case i_i32_sub:
		case i_i32_mul:
		case i_i32_div_s:
		case i_i32_div_u:
		case i_i32_rem_s:
		case i_i32_rem_u:
		case i_i32_and:
		case i_i32_or:
		case i_i32_xor:
		case i_i32_shl:
		case i_i32_shr_s:
		case i_i32_shr_u:
		case i_i32_rotl:
		case i_i32_rotr:
		case i_i64_clz:
		case i_i64_ctz:
		case i_i64_popcnt:
		case i_i64_add:
		case i_i64_sub:
		case i_i64_mul:
		case i_i64_div_s:
		case i_i64_div_u:
		case i_i64_rem_s:
		case i_i64_rem_u:
		case i_i64_and:
		case i_i64_or:
		case i_i64_xor:
		case i_i64_shl:
		case i_i64_shr_s:
		case i_i64_shr_u:
		case i_i64_rotl:
		case i_i64_rotr:
		case i_f32_abs:
		case i_f32_neg:
		case i_f32_ceil:
		case i_f32_floor:
		case i_f32_trunc:
		case i_f32_nearest:
		case i_f32_sqrt:
		case i_f32_add:
		case i_f32_sub:
		case i_f32_mul:
		case i_f32_div:
		case i_f32_min:
		case i_f32_max:
		case i_f32_copysign:
		case i_f64_abs:
		case i_f64_neg:
		case i_f64_ceil:
		case i_f64_floor:
		case i_f64_trunc:
		case i_f64_nearest:
		case i_f64_sqrt:
		case i_f64_add:
		case i_f64_sub:
		case i_f64_mul:
		case i_f64_div:
		case i_f64_min:
		case i_f64_max:
		case i_f64_copysign:
		case i_i32_wrap_i64:
		case i_i32_trunc_f32_s:
		case i_i32_trunc_f32_u:
		case i_i32_trunc_f64_s:
		case i_i32_trunc_f64_u:
		case i_i64_extend_i32_s:
		case i_i64_extend_i32_u:
		case i_i64_trunc_f32_s:
		case i_i64_trunc_f32_u:
		case i_i64_trunc_f64_s:
		case i_i64_trunc_f64_u:
		case i_f32_convert_i32_s:
		case i_f32_convert_i32_u:
		case i_f32_convert_i64_s:
		case i_f32_convert_i64_u:
		case i_f32_demote_f64:
		case i_f64_convert_i32_s:
		case i_f64_convert_i32_u:
		case i_f64_convert_i64_s:
		case i_f64_convert_i64_u:
		case i_f64_promote_f32:
		case i_i32_reinterpret_f32:
		case i_i64_reinterpret_f64:
		case i_f32_reinterpret_i32:
		case i_f64_reinterpret_i64:
		case i_i32_extend8_s:
		case i_i32_extend16_s:
		case i_i64_extend8_s:
		case i_i64_extend16_s:
		case i_i64_extend32_s:
		case i_ref_is_null:
			break;
		case i_bulk_op:
			cursor_push_str(&buf, bulk_op_name(&instr->bulk_op));
			break;
	}

	cursor_push_byte(&buf, 0);
	return buffer;
}

static int eval_const_instr(struct instr *instr, struct errors *errs,
		struct cursor *stack)
{
	//debug("eval_const_instr %s\n", show_instr(instr));

	switch ((enum const_instr)instr->tag) {
	case ci_global_get:
		return note_error(errs, stack, "todo: global_get inside global");
	case ci_ref_null:
		if (unlikely(!cursor_push_nullval(stack))) {
			return note_error(errs, stack, "couldn't push null");
		}
		return 1;
	case ci_ref_func:
		if (unlikely(!cursor_push_funcref(stack, instr->i32))) {
			return note_error(errs, stack, "couldn't push funcref");
		}
		return 1;
	case ci_const_i32:
		if (unlikely(!cursor_push_i32(stack, instr->i32))) {
			return note_error(errs, stack,
					"global push i32 const");
		}
		return 1;
	case ci_const_i64:
		if (unlikely(!cursor_push_i64(stack, instr->i64))) {
			return note_error(errs, stack,
					"global push i64 const");
		}
		return 1;
	case ci_const_f32:
		if (unlikely(!cursor_push_f32(stack, instr->f32))) {
			return note_error(errs, stack,
					"global push f32 const");
		}
		return 1;
	case ci_end:
		return note_error(errs, stack, "unexpected end tag");
	case ci_const_f64:
		if (unlikely(!cursor_push_f64(stack, instr->f64))) {
			return note_error(errs, stack,
					"global push f64 const");
		}
		return 1;
	}

	return note_error(errs, stack, "non-const expr instr %s",
			instr_name(instr->tag));
}

static int parse_const_expr(struct expr_parser *p, struct expr *expr)
{
	u8 tag;
	struct instr instr;

	expr->code = p->code->p;

	while (1) {
		if (unlikely(!pull_byte(p->code, &tag))) {
			return note_error(p->errs, p->code, "oob");
		}

		if (unlikely(!is_const_instr(tag))) {
            //cursor_print_around(p->code, 20);
			return note_error(p->errs, p->code,
					"invalid const expr instruction: '%s'",
					instr_name(tag));
		}

		if (tag == i_end) {
			expr->code_len = (int)(p->code->p - expr->code);
			return 1;
		}

		if (unlikely(!parse_instr(p, tag, &instr))) {
			return note_error(p->errs, p->code,
					"couldn't parse const expr instr '%s'",
					instr_name(tag));
		}

		if (p->stack &&
		    unlikely(!eval_const_instr(&instr, p->errs, p->stack))) {
			return note_error(p->errs, p->code, "eval const instr");
		}
	}

	return 0;
}

static INLINE void make_const_expr_evaluator(struct errors *errs,
		struct cursor *code, struct cursor *stack,
		struct expr_parser *parser)
{
	parser->interp = NULL;
	parser->stack = stack;
	parser->code = code;
	parser->errs = errs;
}

static INLINE void make_const_expr_parser(struct wasm_parser *p,
		struct expr_parser *parser)
{
	parser->interp = NULL;
	parser->stack = NULL;
	parser->code = &p->cur;
	parser->errs = &p->errs;
}

static INLINE int eval_const_expr(struct expr *expr, struct errors *errs,
		struct cursor *stack)
{
	struct cursor code;
	struct expr expr_out;
	struct expr_parser parser;

	make_cursor(expr->code, expr->code + expr->code_len, &code);
	make_const_expr_evaluator(errs, &code, stack, &parser);

	return parse_const_expr(&parser, &expr_out);
}

static INLINE int eval_const_val(struct expr *expr, struct errors *errs,
		struct cursor *stack, struct val *val)
{
	if (!eval_const_expr(expr, errs, stack)) {
		return note_error(errs, stack, "eval const expr");
	}

	if (!cursor_popval(stack, val)) {
		return note_error(errs, stack, "no val to pop?");
	}

	if (cursor_dropval(stack))  {
		return note_error(errs, stack, "stack not empty");
	}

	return 1;
}


static int parse_global(struct wasm_parser *p,
		struct global *global)
{
	struct expr_parser parser;
	struct cursor stack;

	stack.start = p->mem.p;
	stack.p = p->mem.p;
	stack.end = p->mem.end;

	make_const_expr_evaluator(&p->errs, &p->cur, &stack, &parser);

	if (!parse_globaltype(p, &global->type)) {
		return parse_err(p, "type");
	}

	if (!parse_const_expr(&parser, &global->init)) {
		return parse_err(p, "init code");
	}

	if (!cursor_popval(&stack, &global->val)) {
		return parse_err(p, "couldn't eval global expr");
	}

	return 1;
}

static int parse_global_section(struct wasm_parser *p,
		struct globalsec *global_section)
{
	struct global *globals;
	u32 elems, i;

	if (!parse_vector(p, sizeof(*globals), &elems, (void**)&globals)) {
		return parse_err(p, "globals vector");
	}

	for (i = 0; i < elems; i++) {
		if (!parse_global(p, &globals[i])) {
			return parse_err(p, "global #%d/%d", i+1, elems);
		}
	}

	global_section->num_globals = elems;
	global_section->globals = globals;

	return 1;
}

static INLINE void make_interp_expr_parser(struct wasm_interp *interp,
		struct expr_parser *p)
{
	assert(interp);

	p->interp = interp;
	p->code = interp_codeptr(interp);
	p->errs = &interp->errors;

	assert(p->code);
}

static int push_label_checkpoint(struct wasm_interp *interp, struct label **label,
		u8 start_tag, u8 end_tag);

static int parse_instrs_until_at(struct expr_parser *p, u8 stop_instr,
               struct expr *expr, u8 *stopped_at)
{
       u8 tag;
       struct instr op;
#ifdef DEBUG
       static int dbg = 0;
       int dbg_inst = dbg++;
#endif

       expr->code = p->code->p;
       expr->code_len = 0;

       debug("%04lX parse_instrs_until %d for %s starting\n",
		       p->code->p - p->code->start,
		       dbg_inst, instr_name(stop_instr));
       for (;;) {
               if (!pull_byte(p->code, &tag))
                       return note_error(p->errs, p->code, "oob");

	       if ((tag != i_if && tag == stop_instr) ||
		   (stop_instr == i_if && (tag == i_else || tag == i_end))) {
		       //debug("parse_instrs_until ending\n");
               expr->code_len = (int)(p->code->p - expr->code);

		       *stopped_at = tag;

		       debug("%04lX parse_instrs_until @%s %d for %s done\n",
				       p->code->p - p->code->start,
				       instr_name(tag),
				       dbg_inst,
				       instr_name(stop_instr));

#ifdef DEBUG
		       dbg--;
#endif

                       return 1;
               }

		debug("%04lX parsing instr %s (0x%02x)\n",
			p->code->p - 1 - p->code->start, instr_name(tag), tag);
               if (!parse_instr(p, tag, &op)) {
                       return note_error(p->errs, p->code,
			  "parse %s instr (0x%x)", instr_name(tag), tag);
	       }

       }
}

static INLINE int parse_instrs_until(struct expr_parser *p, u8 stop_instr,
               struct expr *expr)
{
	u8 at;
	return parse_instrs_until_at(p, stop_instr, expr, &at);
}

static int parse_elem_func_inits(struct wasm_parser *p, struct elem *elem)
{
	u32 index, i;
	struct expr *expr;

	if (!parse_u32(&p->cur, &elem->num_inits))
		return parse_err(p, "func indices vec read fail");

	if (!(elem->inits = cursor_alloc(&p->mem, elem->num_inits *
					 sizeof(struct expr)))) {
		return parse_err(p, "couldn't alloc vec(funcidx) for elem");
	}

	for (i = 0; i < elem->num_inits; i++) {
		expr = &elem->inits[i];
		expr->code = p->mem.p;

		if (!parse_u32(&p->cur, &index))
			return parse_err(p, "func index %d read fail", i);
		if (!cursor_push_byte(&p->mem, i_ref_func))
			return parse_err(p, "push ref_func instr oob for %d", i);
		if (!leb128_write(&p->mem, index))
			return parse_err(p, "push ref_func u32 index oob for %d", i);
		if (!cursor_push_byte(&p->mem, i_end))
			return parse_err(p, "push i_end for init %d", i);

		expr->code_len = (int)(p->mem.p - expr->code);
	}

	return 1;
}


static int parse_element(struct wasm_parser *p, struct elem *elem)
{
	u8 tag = 0;
	struct expr_parser expr_parser;
	(void)elem;

	make_expr_parser(&p->errs, &p->cur, &expr_parser);

	if (!pull_byte(&p->cur, &tag))
		return parse_err(p, "tag");

	if (tag > 7)
		return parse_err(p, "expected tag 0x00 to 0x07, got 0x%02x", tag);

	switch (tag) {
	case 0x00:
		if (!parse_instrs_until(&expr_parser, i_end, &elem->offset))
			return parse_err(p, "elem 0x00 offset expr");

		// func inits
		if (!parse_elem_func_inits(p, elem))
			return parse_err(p, "generate func index exprs");


		elem->mode = elem_mode_active;
		elem->tableidx = 0;
		elem->reftype = funcref;
		break;

	default:
		return parse_err(p, "implement parse element 0x%02x", tag);
	}

	return 1;
}

static int parse_custom_section(struct wasm_parser *p, u32 size,
		struct customsec *section)
{
	u8 *start;
	start = p->cur.p;

	if (p->module.custom_sections + 1 > MAX_CUSTOM_SECTIONS)
		return parse_err(p, "more than 32 custom sections!");

	if (!parse_name(p, &section->name))
		return parse_err(p, "name");

	section->data = p->cur.p;
	section->data_len = (int)(size - (p->cur.p - start));

	debug("custom sec minus %ld\n", p->cur.p - start);

	if (!strcmp(section->name, "name")) {
		if (!parse_name_section(p, &p->module.name_section, section)) {
			return parse_err(p,
					"failed to parse name custom section");
		}
	} else {
		p->cur.p += section->data_len;
	}

	p->module.custom_sections++;

	return 1;
}

static int parse_element_section(struct wasm_parser *p, struct elemsec *elemsec)
{
	struct elem *elements;
	u32 count, i;

	if (!parse_vector(p, sizeof(struct elem), &count, (void**)&elements))
		return parse_err(p, "elements vec");

	for (i = 0; i < count; i++) {
		if (!parse_element(p, &elements[i]))
			return parse_err(p, "element %d of %d", i+1, count);
	}

	elemsec->num_elements = count;
	elemsec->elements = elements;

	return 1;
}

static int parse_memory_section(struct wasm_parser *p,
		struct memsec *memory_section)
{
	struct limits *mems;
	u32 elems, i;

	if (!parse_vector(p, sizeof(*mems), &elems, (void**)&mems)) {
		return parse_err(p, "mems vector");
	}

	for (i = 0; i < elems; i++) {
		if (!parse_limits(p, &mems[i])) {
			return parse_err(p, "memory #%d/%d", i+1, elems);
		}
	}

	memory_section->num_mems = elems;
	memory_section->mems = mems;

	return 1;
}

static int parse_start_section(struct wasm_parser *p,
		struct startsec *start_section)
{
	if (!parse_u32(&p->cur, &start_section->start_fn)) {
		return parse_err(p, "start_fn index");
	}

	return 1;
}

static INLINE int parse_byte_vector(struct wasm_parser *p, u8 **data,
		u32 *data_len)
{
	if (!parse_u32(&p->cur, data_len)) {
		return parse_err(p, "len");
	}

	if (p->cur.p + *data_len > p->cur.end) {
		return parse_err(p, "byte vector overflow");
	}

	*data = p->cur.p;
	p->cur.p += *data_len;

	return 1;
}

static int parse_wdata(struct wasm_parser *p, struct wdata *data)
{
	struct expr_parser parser;
	u8 tag;

	if (!pull_byte(&p->cur, &tag)) {
		return parse_err(p, "tag");
	}

	if (tag > 2) {
		//cursor_print_around(&p->cur, 10);
		return parse_err(p, "invalid datasegment tag: 0x%x", tag);
	}

	make_const_expr_parser(p, &parser);

	switch (tag) {
	case 0:
		data->mode = datamode_active;
		data->active.mem_index = 0;

		if (!parse_const_expr(&parser, &data->active.offset_expr)) {
			return parse_err(p, "const expr");
		}

		if (!parse_byte_vector(p, &data->bytes, &data->bytes_len)) {
			return parse_err(p, "bytes vector");
		}

		break;

	case 1:
		data->mode = datamode_passive;

		if (!parse_byte_vector(p, &data->bytes, &data->bytes_len)) {
			return parse_err(p, "passive bytes vector");
		}

		break;

	case 2:
		data->mode = datamode_active;

		if (!parse_u32(&p->cur, &data->active.mem_index))  {
			return parse_err(p, "read active data mem_index");
		}

		if (!parse_const_expr(&parser, &data->active.offset_expr)) {
			return parse_err(p, "read active data (w/ mem_index) offset_expr");
		}

		if (!parse_byte_vector(p, &data->bytes, &data->bytes_len)) {
			return parse_err(p, "active (w/ mem_index) bytes vector");
		}

		break;
	}

	return 1;
}

static int parse_data_count_section(struct wasm_parser *p, struct datasec *section)
{
	if (!parse_u32(&p->cur, &section->num_datas))
		return parse_err(p, "data count");
	return 1;
}

static int parse_data_section(struct wasm_parser *p, struct datasec *section)
{
	struct wdata *data;
	u32 elems, i;

	if (!parse_vector(p, sizeof(*data), &elems, (void**)&data))
		return parse_err(p, "datas vector");

	if (was_section_parsed(&p->module, section_data_count) &&
			elems != section->num_datas) {
		return parse_err(p, "we got a data count section with %d "
				"elements but the data section says it has %d "
				"elements. what's up with that?",
				section->num_datas, elems);
	}

	for (i = 0; i < elems; i++) {
		if (!parse_wdata(p, &data[i])) {
			return parse_err(p, "data segment #%d/%d", i+1, elems);
		}
	}

	section->num_datas = elems;
	section->datas = data;

	return 1;
}

static int parse_table_section(struct wasm_parser *p,
		struct tablesec *table_section)
{
	struct table *tables;
	u32 elems, i;

	if (!parse_vector(p, sizeof(*tables), &elems, (void**)&tables)) {
		return parse_err(p, "tables vector");
	}

	for (i = 0; i < elems; i++) {
		if (!parse_table(p, &tables[i])) {
			parse_err(p, "table #%d/%d", i+1, elems);
			return 0;
		}
	}

	table_section->num_tables = elems;
	table_section->tables = tables;

	return 1;
}

static int parse_function_section(struct wasm_parser *p,
		struct funcsec *funcsec)
{
	u32 i, elems, *indices;

	if (!parse_vector(p, sizeof(*indices), &elems, (void**)&indices)) {
		return parse_err(p, "indices");
	}

	for (i = 0; i < elems; i++) {
		if (!parse_u32(&p->cur, &indices[i])) {
			parse_err(p, "typeidx #%d", i);
			return 0;
		}
	}

	funcsec->type_indices = indices;
	funcsec->num_indices = elems;

	return 1;
}

static int parse_import_table(struct wasm_parser *p, struct limits *limits)
{
	if (!consume_byte(&p->cur, 0x70)) {
		parse_err(p, "elemtype != 0x70");
		return 0;
	}

	if (!parse_limits(p, limits)) {
		parse_err(p, "limits");
		return 0;
	}

	return 1;
}

static int parse_importdesc(struct wasm_parser *p, struct importdesc *desc)
{
	u8 tag;

	if (!pull_byte(&p->cur, &tag)) {
		parse_err(p, "oom");
		return 0;
	}

	desc->type = (enum import_type)tag;

	switch (desc->type) {
	case import_func:
		if (!parse_u32(&p->cur, &desc->typeidx)) {
			parse_err(p, "typeidx");
			return 0;
		}

		return 1;

	case import_table:
		return parse_import_table(p, &desc->tabletype);

	case import_mem:
		if (!parse_limits(p, &desc->memtype)) {
			parse_err(p, "memtype limits");
			return 0;
		}

		return 1;

	case import_global:
		if (!parse_globaltype(p, &desc->globaltype)) {
			parse_err(p, "globaltype");
			return 0;
		}

		return 1;
	}

	parse_err(p, "unknown importdesc tag %02x", tag);
	return 0;
}

static int find_builtin(struct builtin *builtins, int num_builtins, const char *name)
{
	struct builtin *b;
	int i;

	for (i = 0; i < num_builtins; i++) {
		b = &builtins[i];
		if (!strcmp(b->name, name))
			return i;
	}
	return -1;
}

static int parse_import(struct wasm_parser *p, struct import *import)
{
	import->resolved_builtin = -1;

	if (!parse_name(p, &import->module_name))
		return parse_err(p, "module name");

	if (!parse_name(p, &import->name))
		return parse_err(p, "name");

	if (!parse_importdesc(p, &import->desc))
		return parse_err(p, "desc");

	if (import->desc.type == import_func) {
		import->resolved_builtin =
			find_builtin(p->builtins, p->num_builtins, import->name);
	}

	return 1;
}

static int parse_import_section(struct wasm_parser *p, struct importsec *importsec)
{
	u32 elems, i;
	struct import *imports;

	if (!parse_vector(p, sizeof(*imports), &elems, (void**)&imports)) {
		return parse_err(p, "imports");
	}

	for (i = 0; i < elems; i++) {
		if (!parse_import(p, &imports[i])) {
			return parse_err(p, "import #%d", i);
		}
	}

	importsec->imports = imports;
	importsec->num_imports = elems;

	return 1;
}

/* type section is just a vector of function types */
static int parse_type_section(struct wasm_parser *p, struct typesec *typesec)
{
	u32 elems, i;
	struct functype *functypes;

	typesec->num_functypes = 0;
	typesec->functypes = NULL;

	if (!parse_vector(p, sizeof(*functypes), &elems, (void**)&functypes)) {
		parse_err(p, "functypes");
		return 0;
	}

	for (i = 0; i < elems; i++) {
		if (!parse_func_type(p, &functypes[i])) {
			parse_err(p, "functype #%d", i);
			return 0;
		}
	}

	typesec->functypes = functypes;
	typesec->num_functypes = elems;

	return 1;
}

static int parse_section_by_tag(struct wasm_parser *p, enum section_tag tag,
				u32 size)
{
	(void)size;
	switch (tag) {
	case section_custom:
		if (!parse_custom_section(p, size,
			&p->module.custom_section[p->module.custom_sections]))
			return parse_err(p, "custom section");
		return 1;
	case section_type:
		if (!parse_type_section(p, &p->module.type_section)) {
			return parse_err(p, "type section");
		}
		return 1;
	case section_import:
		if (!parse_import_section(p, &p->module.import_section)) {
			return parse_err(p, "import section");
		}
		return 1;
	case section_function:
		if (!parse_function_section(p, &p->module.func_section)) {
			return parse_err(p, "function section");
		}
		return 1;
	case section_table:
		if (!parse_table_section(p, &p->module.table_section)) {
			return parse_err(p, "table section");
		}
		return 1;
	case section_memory:
		if (!parse_memory_section(p, &p->module.memory_section)) {
			return parse_err(p, "memory section");
		}
		return 1;
	case section_global:
		if (!parse_global_section(p, &p->module.global_section)) {
			return parse_err(p, "global section");
		}
		return 1;
	case section_export:
		if (!parse_export_section(p, &p->module.export_section)) {
			return parse_err(p, "export section");
		}
		return 1;
	case section_start:
		if (!parse_start_section(p, &p->module.start_section)) {
			return parse_err(p, "start section");
		}
		return 1;

	case section_element:
		if (!parse_element_section(p, &p->module.element_section)) {
			return parse_err(p, "element section");
		}
		return 1;

	case section_code:
		if (!parse_code_section(p, &p->module.code_section)) {
			return parse_err(p, "code section");
		}
		return 1;

	case section_data:
		if (!parse_data_section(p, &p->module.data_section))
			return parse_err(p, "data section");
		return 1;

	case section_data_count:
		if (!parse_data_count_section(p, &p->module.data_section))
			return parse_err(p, "data count section");
		return 1;

	default:
		return parse_err(p, "invalid section tag %d", tag);
	}

	return 1;
}

static const char *section_str(enum section_tag tag)
{
	switch (tag) {
		case section_custom:
			return "custom";
		case section_type:
			return "type";
		case section_import:
			return "import";
		case section_function:
			return "function";
		case section_table:
			return "table";
		case section_memory:
			return "memory";
		case section_global:
			return "global";
		case section_export:
			return "export";
		case section_start:
			return "start";
		case section_element:
			return "element";
		case section_code:
			return "code";
		case section_data:
			return "data";
		default:
			return "invalid";
	}

}

static int parse_section(struct wasm_parser *p)
{
	enum section_tag tag;
	struct section;
	u32 bytes;

	if (!parse_section_tag(&p->cur, &tag)) {
		parse_err(p, "section tag");
		return 2;
	}

	if (!parse_u32(&p->cur, &bytes)) {
		return parse_err(p, "section len");
	}

	if (!parse_section_by_tag(p, tag, bytes)) {
		return parse_err(p, "%s (%d bytes)", section_str(tag), bytes);
	}

	p->module.parsed |= 1 << tag;

	return 1;
}

static struct builtin *builtin_func(struct builtin *builtins, u32 num_builtins, u32 ind)
{
	if (unlikely(ind >= num_builtins)) {
		printf("UNUSUAL: invalid builtin index %d (max %d)\n", ind,
				num_builtins-1);
		return NULL;
	}
	return &builtins[ind];
}

static const char *find_exported_function_name(struct module *module, u32 fn)
{
	u32 i;
	struct wexport *export;

	if (!was_section_parsed(module, section_export))
		return NULL;

	for (i = 0; i < module->export_section.num_exports; i++) {
		export = &module->export_section.exports[i];
		if (export->desc == export_func &&
		    export->index == fn) {
			return export->name;
		}
	}

	return NULL;
}

static const char *find_debug_function_name(struct module *module, u32 fn)
{
	u32 i;
	struct nameassoc *assoc;

	if (!was_name_section_parsed(module, name_subsection_funcs))
		return NULL;

	for (i = 0; i < module->name_section.func_names.num_names; i++) {
		assoc = &module->name_section.func_names.names[i];
		if (fn == assoc->index) {
			//debug("found fn debug name %d -> %s\n", fn, assoc->name);
			return assoc->name;
		}
	}

	debug("fn %d debug name not found\n", fn);

	return NULL;
}

static const char *find_function_name(struct module *module, u32 fn)
{
	const char *name;

	if ((name = find_exported_function_name(module, fn))) {
		return name;
	}

	if ((name = find_debug_function_name(module, fn))) {
		return name;
	}

	return "unknown";
}

static int count_fn_locals(struct func *func)
{
	u32 i, num_locals = 0;

	num_locals += func->functype->params.num_valtypes;

	if (func->type == func_type_wasm) {
		// counts locals of the same type
		for (i = 0; i < func->wasm_func->num_local_defs; i++) {
			num_locals += func->wasm_func->local_defs[i].num_types;
		}
	}

	return num_locals;
}

static void make_builtin_func(struct func *func, const char *name,
		struct functype *type, struct builtin *builtin, u32 idx)
{
	func->name = name;
	func->builtin = builtin;
	func->functype = type;
	func->type = func_type_builtin;
	func->num_locals = count_fn_locals(func);
	func->idx = idx;
}

static int make_func_lookup_table(struct wasm_parser *parser)
{
	u32 i, num_imports, num_func_imports, num_internal_funcs, typeidx, fn;
	struct import *import;
	struct importsec *imports;
	struct func *func;
	struct builtin *builtin;

	fn = 0;

	imports = &parser->module.import_section;
	num_func_imports = count_imported_functions(&parser->module);
	num_internal_funcs = count_internal_functions(&parser->module);
	parser->module.num_funcs = num_func_imports + num_internal_funcs;

	if (!(parser->module.funcs =
		cursor_alloc(&parser->mem, sizeof(struct func) *
			     parser->module.num_funcs))) {
		return parse_err(parser, "oom");
	}

	/* imports */
	num_imports = count_imports(&parser->module, NULL);
	debug("num_imports %d\n", num_imports);

	for (i = 0; i < num_imports; i++) {
		import = &imports->imports[i];

		if (import->desc.type != import_func)
			continue;

		func = &parser->module.funcs[fn++];

		if (import->resolved_builtin == -1) {
			debug("warning: %s not resolved\n", func->name);
			builtin = NULL;
		} else {
			builtin = builtin_func(parser->builtins, parser->num_builtins, import->resolved_builtin);
		}

		make_builtin_func(
			func,
			import->name,
			&parser->module.type_section.functypes[import->desc.typeidx],
			builtin,
			fn
			);
	}

	/* module fns */
	for (i = 0; i < num_internal_funcs; i++, fn++) {
		func = &parser->module.funcs[fn];

		typeidx = parser->module.func_section.type_indices[i];
		func->type = func_type_wasm;
		func->wasm_func = &parser->module.code_section.funcs[i];
		func->functype = &parser->module.type_section.functypes[typeidx];
		func->name = find_function_name(&parser->module, fn);
		func->num_locals = count_fn_locals(func);
		func->idx = fn;
	}

	assert(fn == parser->module.num_funcs);

	return 1;
}


int parse_wasm(struct wasm_parser *p)
{
	p->module.parsed = 0;
	p->module.custom_sections = 0;

	if (!consume_bytes(&p->cur, WASM_MAGIC, sizeof(WASM_MAGIC))) {
		parse_err(p, "magic");
		goto fail;
	}

	if (!consume_u32(&p->cur, WASM_VERSION)) {
		parse_err(p, "version");
		goto fail;
	}

	while (1) {
		if (cursor_eof(&p->cur))
			break;

		if (!parse_section(p)) {
			parse_err(p, "section");
			goto fail;
		}
	}

	if (!make_func_lookup_table(p)) {
		return parse_err(p, "failed making func lookup table");
	}

	//print_module(&p->module);
	debug("module parse success!\n\n");
	return 1;

fail:
	debug("\npartially parsed module:\n");
	print_module(&p->module);
	debug("parse failure backtrace:\n");
	print_error_backtrace(&p->errs);
	return 0;
}

static INLINE int interp_prep_binop(struct wasm_interp *interp, struct val *lhs,
		struct val *rhs, struct val *c, enum valtype typ)
{
	c->type = typ;

	if (unlikely(!cursor_popval(&interp->stack, rhs)))
		return interp_error(interp, "couldn't pop first val");

	if (unlikely(!cursor_popval(&interp->stack, lhs)))
		return interp_error(interp, "couldn't pop second val");

	if (unlikely(lhs->type != typ || rhs->type != typ)) {
	        return interp_error(interp, "type mismatch, %s or %s != %s",
			valtype_name(lhs->type),
			valtype_name(rhs->type),
			valtype_name(typ));
	}

	return 1;
}

static INLINE int set_local(struct wasm_interp *interp, u32 ind,
			    struct val *val)
{
	struct callframe *frame;
	struct val *local;

	if (unlikely(!(frame = top_callframe(&interp->callframes))))
		return interp_error(interp, "no callframe?");

	if (unlikely(!(local = get_local(interp, ind))))
		return interp_error(interp, "no local?");

	memcpy(local, val, sizeof(*val));
	return 1;
}

static INLINE int interp_local_tee(struct wasm_interp *interp, u32 index)
{
	struct val *val;

	if (unlikely(!(val = stack_topval(interp))))
		return interp_error(interp, "pop");

	if (unlikely(!set_local(interp, index, val)))
		return interp_error(interp, "set local");

	return 1;
}

static int interp_local_set(struct wasm_interp *interp, u32 index)
{
	struct val val;

	if (unlikely(!interp_local_tee(interp, index)))
		return interp_error(interp, "tee set");

	if (unlikely(!stack_popval(interp, &val)))
		return interp_error(interp, "pop");

	return 1;
}

static INLINE int interp_local_get(struct wasm_interp *interp, u32 index)
{
	struct val *val;

	if (unlikely(!(val = get_local(interp, index)))) {
		return interp_error(interp, "get local");
	}

	return stack_pushval(interp, val);
}

static INLINE void make_i64_val(struct val *val, s64 v)
{
	val->type = val_i64;
	val->num.i64 = v;
}

static INLINE int interp_i64_xor(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	c.num.i64 = lhs.num.i64 ^ rhs.num.i64;
	return stack_pushval(interp, &c);
}

/*
static INLINE int interp_f32_min(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_f32)))
		return interp_error(interp, "binop prep");
	c.num.f32 = lhs.num.f32 < rhs.num.f32 ? lhs.num.f32 : rhs.num.f32;
	return stack_pushval(interp, &c);
}
 */

static INLINE int interp_f32_max(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_f32)))
		return interp_error(interp, "binop prep");
	c.num.f32 = lhs.num.f32 > rhs.num.f32 ? lhs.num.f32 : rhs.num.f32;
	return stack_pushval(interp, &c);
}

static INLINE int interp_i64_div_u(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	if (rhs.num.u64 == 0)
		return interp_error(interp, "congrats, you divided by zero");
	c.num.u64 = lhs.num.u64 / rhs.num.u64;
	return stack_pushval(interp, &c);
}

static int interp_i64_eqz(struct wasm_interp *interp)
{
	struct val a, res;
	if (unlikely(!stack_pop_valtype(interp, val_i64, &a)))
		return interp_error(interp, "pop val");
	res.type = val_i32;
	res.num.u32 = a.num.i64 == 0;
	return cursor_pushval(&interp->stack, &res);
}

static INLINE int interp_f32_sqrt(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f32(interp))))
		return interp_error(interp, "pop");
	val->num.f32 = sqrt(val->num.f32);
	return 1;
}

static INLINE int interp_f64_sqrt(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	val->num.f64 = sqrt(val->num.f64);
	return 1;
}

static INLINE int interp_f64_floor(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	val->num.f64 = floor(val->num.f64);
	return 1;
}

static INLINE int interp_f64_ceil(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	val->num.f64 = ceil(val->num.f64);
	return 1;
}

static INLINE int interp_f32_abs(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f32(interp))))
		return interp_error(interp, "pop");
	if (val->num.f32 >= 0)
		return 1;
	val->num.f32 = -val->num.f32;
	return 1;
}

static INLINE int interp_f64_neg(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	val->num.f64 = -val->num.f64;
	return 1;
}

static INLINE int interp_f64_abs(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	if (val->num.f64 >= 0)
		return 1;
	val->num.f64 = -val->num.f64;
	return 1;
}

static INLINE int interp_f64_div(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_f64)))
		return interp_error(interp, "binop prep");
	if (rhs.num.f64 == 0)
		return interp_error(interp, "congrats, you divided by zero");
	c.num.f64 = lhs.num.f64 / rhs.num.f64;
	return stack_pushval(interp, &c);
}

static INLINE int interp_f32_div(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_f32)))
		return interp_error(interp, "binop prep");
	if (rhs.num.f32 == 0)
		return interp_error(interp, "congrats, you divided by zero");
	c.num.f32 = lhs.num.f32 / rhs.num.f32;
	return stack_pushval(interp, &c);
}

static INLINE int interp_i32_div_s(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	if (rhs.num.i32 == 0)
		return interp_error(interp, "congrats, you divided by zero");
	c.num.i32 = lhs.num.i32 / rhs.num.i32;
	return stack_pushval(interp, &c);
}

static INLINE int interp_i32_div_u(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	if (rhs.num.u32 == 0)
		return interp_error(interp, "congrats, you divided by zero");
	c.num.u32 = lhs.num.u32 / rhs.num.u32;
	return stack_pushval(interp, &c);
}

const unsigned int ROTMASK = (CHAR_BIT*sizeof(uint32_t) - 1);  // assumes width is a power of 2.

static inline uint32_t rotl32 (uint32_t n, unsigned int c)
{
	return (n << shiftmask32(c)) | (n >> shiftmask32(0 - c));
}

static inline uint32_t rotr32 (uint32_t n, unsigned int c)
{
	return (n >> shiftmask32(c)) | (n << shiftmask32(0 - c));
}

static INLINE int interp_i32_rotr(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	c.num.u32 = rotr32(lhs.num.u32, rhs.num.u32);
	return stack_pushval(interp, &c);
}

static INLINE int interp_i32_rotl(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	c.num.u32 = rotl32(lhs.num.u32, rhs.num.u32);
	return stack_pushval(interp, &c);
}

static INLINE int interp_i64_const(struct wasm_interp *interp, s64 c)
{
	struct val val;
	make_i64_val(&val, c);
	return cursor_pushval(&interp->stack, &val);
}

static INLINE int interp_i32_const(struct wasm_interp *interp, u32 c)
{
	struct val val;
	make_i32_val(&val, c);
	return cursor_pushval(&interp->stack, &val);
}

static INLINE int interp_f64_const(struct wasm_interp *interp, double c)
{
	struct val val;
	make_f64_val(&val, c);
	return stack_pushval(interp, &val);
}

static INLINE int interp_i32_and(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	return stack_push_i32(interp, lhs.num.u32 & rhs.num.u32);
}

static INLINE int interp_i64_and(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	return stack_push_i64(interp, lhs.num.u64 & rhs.num.u64);
}


#define BINOP(type, name, op) \
static INLINE int interp_##type##_##name(struct wasm_interp *interp) \
{ \
	struct val lhs, rhs, c; \
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_##type))) \
		return interp_error(interp, "binop prep"); \
	c.num.type = lhs.num.type op rhs.num.type; \
	return stack_pushval(interp, &c); \
}

#define BINOP2(type, optype, name, op) \
static INLINE int interp_##type##_##name(struct wasm_interp *interp) \
{ \
	struct val lhs, rhs, c; \
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_##type))) \
		return interp_error(interp, "binop prep"); \
	return stack_push_i32(interp, lhs.num.optype op rhs.num.optype); \
}

BINOP(f64, mul, *)
BINOP(f32, mul, *)
BINOP(i32, mul, *)
BINOP(i64, mul, *)

BINOP(f64, sub, -)
BINOP(f32, sub, -)
BINOP(i32, sub, -)
BINOP(i64, sub, -)

BINOP(f64, add, +)
BINOP(f32, add, +)
BINOP(i32, add, +)
BINOP(i64, add, +)

BINOP(i32, or, |)
BINOP(i64, or, |)

BINOP2(i32, i32, lt_s, <)
BINOP2(i64, i64, lt_s, <)
BINOP2(i32, u32, lt_u, <)
BINOP2(i64, u64, lt_u, <)
BINOP2(f32, f32, lt, <)
BINOP2(f64, f64, lt, <)

BINOP2(i32, i32, gt_s, >)
BINOP2(i64, i64, gt_s, >)
BINOP2(i32, u32, gt_u, >)
BINOP2(i64, u64, gt_u, >)
BINOP2(f32, f32, gt, >)
BINOP2(f64, f64, gt, >)

BINOP2(i32, i32, le_s, <=)
BINOP2(i64, i64, le_s, <=)
BINOP2(i32, u32, le_u, <=)
BINOP2(i64, u64, le_u, <=)
BINOP2(f32, f32, le, <=)
BINOP2(f64, f64, le, <=)

BINOP2(i32, i32, ge_s, >=)
BINOP2(i64, i64, ge_s, >=)
BINOP2(i32, u32, ge_u, >=)
BINOP2(i64, u64, ge_u, >=)
BINOP2(f32, f32, ge, >=)
BINOP2(f64, f64, ge, >=)

BINOP2(f32, f32, eq, ==)
BINOP2(f64, f64, eq, ==)
BINOP2(f32, f32, ne, !=)
BINOP2(f64, f64, ne, !=)

static int interp_i32_rem_s(struct wasm_interp *interp)
{
    struct val lhs, rhs, c;
    if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
        return interp_error(interp, "binop prep");
    c.num.i32 = lhs.num.i32 % rhs.num.i32;
    return stack_pushval(interp, &c);
}

static int interp_i32_rem_u(struct wasm_interp *interp)
{
    struct val lhs, rhs, c;
    if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
        return interp_error(interp, "binop prep");
    c.num.u32 = lhs.num.u32 % rhs.num.u32;
    return stack_pushval(interp, &c);
}


static INLINE int interp_f32_const(struct wasm_interp *interp, float c)
{
	struct val val;
	make_f32_val(&val, c);
	return cursor_pushval(&interp->stack, &val);
}

static INLINE int interp_f32_neg(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f32(interp))))
		return interp_error(interp, "pop");
	val->num.f32 = -val->num.f32;
	return 1;
}

static INLINE int interp_f32_reinterpret_i32(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_i32(interp))))
		return interp_error(interp, "pop");
	val->type = val_f32;
	return 1;
}

static INLINE int interp_f64_convert_i32_u(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_i32(interp))))
		return interp_error(interp, "pop");
	make_f64_val(val, (double)val->num.i32);
	return 1;
}

static INLINE int interp_i32_trunc_f64_u(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	make_i32_val(val, (u32)val->num.f64);
	return 1;
}

static INLINE int interp_f32_convert_i32_u(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_i32(interp))))
		return interp_error(interp, "pop");
	make_f32_val(val, (float)val->num.u32);
	return 1;
}

static INLINE int interp_i32_trunc_f32_s(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f32(interp))))
		return interp_error(interp, "pop");
	make_i32_val(val, (int)val->num.f32);
	return 1;
}

static INLINE int interp_f64_reinterpret_i64(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_i64(interp))))
		return interp_error(interp, "pop");
	val->type = val_f64;

	return 1;
}

static INLINE int interp_i64_reinterpret_f64(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	val->type = val_i64;
	return 1;
}

static INLINE int interp_f64_convert_i64_u(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_i64(interp))))
		return interp_error(interp, "pop");
	make_f64_val(val, (double)val->num.u64);
	return 1;
}

static INLINE int interp_f64_convert_i32_s(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_i32(interp))))
		return interp_error(interp, "pop");
	make_f64_val(val, (double)val->num.i32);
	return 1;
}

static INLINE int interp_f32_demote_f64(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	make_f32_val(val, (float)val->num.f64);
	return 1;
}

static INLINE int interp_i32_trunc_f64_s(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f64(interp))))
		return interp_error(interp, "pop");
	make_i32_val(val, (int)val->num.f64);
	return 1;
}

static INLINE int interp_f64_promote_f32(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f32(interp))))
		return interp_error(interp, "pop");
	make_f64_val(val, (double)val->num.f32);
	return 1;
}

static INLINE int interp_i32_reinterpret_f32(struct wasm_interp *interp)
{
	struct val *val;
	if (unlikely(!(val = stack_top_f32(interp))))
		return interp_error(interp, "pop");
	val->type = val_i32;
	return 1;
}

static INLINE int interp_f32_convert_i32_s(struct wasm_interp *interp)
{
	float f;
	struct val *val;
	if (unlikely(!(val = stack_top_i32(interp))))
		return interp_error(interp, "pop");
	f = (float)val->num.i32;
	make_f32_val(val, f);
	return 1;
}

static INLINE int count_local_resolvers(struct wasm_interp *interp, int *count)
{
	int offset;
	u8 *p;
	*count = 0;
	if (unlikely(!cursor_top_int(&interp->resolver_offsets, &offset))) {
		return interp_error(interp, "no top resolver offset?");
	}
	p = interp->resolver_stack.start + offset * sizeof(struct resolver);
	if (unlikely(p < interp->resolver_stack.start ||
		     p >= interp->resolver_stack.end)) {
		return interp_error(interp, "resolver offset oob?");
	}
	*count = (int)((interp->resolver_stack.p - p) / sizeof(struct resolver));
	//debug("offset %d count %d stack.p - p %ld\n", offset, *count, interp->resolver_stack.p - p);
	return 1;
}

static INLINE u32 count_stack_vals(struct cursor *stack)
{
	return (u32)cursor_count(stack, sizeof(struct val));
}

static INLINE int drop_callframe_return(struct wasm_interp *interp, int returning)
{
	int offset, drop;
	u32 cnt;
	struct callframe *frame;
	struct func *func;

#ifdef DEBUG
	int count, from_fn, to_fn;
	const char *from, *to;

	if (unlikely(!count_local_resolvers(interp, &count))) {
		return interp_error(interp, "count local resolvers");
	}

	if (unlikely(count != 0)) {
		return interp_error(interp, "unclean callframe drop, still have"
				" %d unpopped labels", count);
	}

	frame = top_callframe(&interp->callframes);
	if (!frame) {
		from = "(aux)";
		from_fn = -1;
	} else {
		from = get_function_name(interp->module, frame->func->idx);
		from_fn = frame->func->idx;
	}

	if (!(frame = top_callframes(&interp->callframes, 1))) {
		to = "(aux)";
		to_fn = -1;
	} else {
		to = get_function_name(interp->module, frame->func->idx);
		to_fn = frame->func->idx;
	}
#endif
	frame = top_callframe(&interp->callframes);
	func = frame->func;

	if (unlikely(!cursor_popint(&interp->resolver_offsets, &offset)))
		return interp_error(interp, "pop resolver_offsets");

	cnt = count_stack_vals(&interp->stack);

	if (returning)  {
		drop = cnt - frame->prev_stack_items - 
				func->functype->result.num_valtypes;
		if (drop > 0 &&
		    !cursor_dropn(&interp->stack, sizeof(struct val), drop)) {
			return interp_error(interp,
				"error dropping extra stack values in return. "
				"drop:%d vals:%d prev:%d ret:%d",
				drop, cnt, frame->prev_stack_items,
				func->functype->result.num_valtypes);
		}

	} else if (unlikely(cnt - frame->prev_stack_items !=
				func->functype->result.num_valtypes)) {
		return interp_error(interp,
				"%s:%d extra values on stack: have %d-prev:%d=%d, expected %d",
				func->name, frame->func->idx, cnt,
				frame->prev_stack_items,
				cnt - frame->prev_stack_items,
				func->functype->result.num_valtypes);
	}

	// free frame locals
	interp->locals.p = (u8*)frame->locals;

	debug("returning from %s:%d to %s:%d\n", from, from_fn, to, to_fn);

	return cursor_drop_callframe(&interp->callframes);
}

static INLINE int drop_callframe(struct wasm_interp *interp)
{
	return drop_callframe_return(interp, 1);
}

static void make_default_val(struct val *val)
{
	switch (val->type) {
	case val_i32:
		val->num.i32 = 0;
		break;
	case val_i64:
		val->num.i64 = 0;
		break;
	case val_f32:
		val->num.f32 = 0.0;
		break;
	case val_f64:
		val->num.f64 = 0.0;
		break;
	case val_ref_null:
	case val_ref_func:
	case val_ref_extern:
		val->ref.addr = 0;
		break;
	}
}

static struct val *alloc_frame_locals(struct wasm_interp *interp,
		struct func *func)
{
	struct val *locals;
	u32 size;

	size = func->num_locals * sizeof(struct val);

	if (!(locals = cursor_malloc(&interp->locals, size))) {
		debug("alloc_locals err size %d\n", size);
		interp_error(interp, "could not alloc locals for %s",
				func->name);
		return NULL;
	}

	return locals;
}

static int prepare_call(struct wasm_interp *interp, struct func *func,
		struct val **locals, int *prev_items)
{
	static char buf[128];
	struct val *local;
	struct val val;
	u32 i, j, ind;

	*prev_items = count_stack_vals(&interp->stack);

	if (!(*locals = alloc_frame_locals(interp, func)))
		return interp_error(interp, "locals stack oom");

	debug("new stack size %ld/%ld (%f%%)\n",
			((u8*)*locals) - interp->locals.start,
			interp->locals.end - interp->locals.start,
			100.0*((double)(((u8*)*locals) - interp->locals.start)/
			  (double)(interp->locals.end - interp->locals.start)));

	/* push params as locals */
	for (i = 0; i < func->functype->params.num_valtypes; i++) {
		*prev_items = *prev_items - 1;

		ind = func->functype->params.num_valtypes-1-i;
		local = &(*locals)[ind];
		local->type = (enum valtype)func->functype->params.valtypes[ind];
		//ind = i;

		if (unlikely(!cursor_popval(&interp->stack, &val))) {
			return interp_error(interp,
				"not enough arguments for call to %s: [%s], needed %d args, got %d",
				func->name,
				functype_str(func->functype, buf, sizeof(buf)),
				func->functype->params.num_valtypes,
				ind);
		}

		if (unlikely(val.type != local->type)) {
			return interp_error(interp,
				"call parameter %d type mismatch. got %s, expected %s",
				ind+1,
				valtype_name(val.type),
				valtype_name(local->type));
		}

#ifdef DEBUG
		debug("setting param %d (%s) to ",
				ind, valtype_name(local->type));
		print_val(&val); printf("\n");
#endif
		memcpy(local, &val, sizeof(struct val));
	}

	if (func->type == func_type_builtin)
		return 1;

	ind = i;

	for (i = 0; i < func->wasm_func->num_local_defs; i++) {
	for (j = 0; j < func->wasm_func->local_defs[i].num_types; j++, ind++) {
		assert(ind < func->num_locals);
		local = (*locals) + ind;

		debug("initializing local %d to type %s\n",
			ind-func->functype->params.num_valtypes,
			valtype_name(func->wasm_func->local_defs[i].type));

		local->type = func->wasm_func->local_defs[i].type;
		make_default_val(local);
	}
	}

	return 1;
}

static INLINE int call_wasm_func(struct wasm_interp *interp, struct func *func)
{
	struct callframe callframe;
	struct val *locals;
	int prev_items;

	if (!prepare_call(interp, func, &locals, &prev_items))
		return interp_error(interp, "prepare args");

	/* update current function and push it to the callframe as well */
	make_cursor(func->wasm_func->code.code,
			func->wasm_func->code.code + func->wasm_func->code.code_len,
			&callframe.code);

	callframe.func = func;
	callframe.locals = locals;
	callframe.prev_stack_items = prev_items;

	assert(func->wasm_func->code.code_len > 0);

	if (unlikely(!push_callframe(interp, &callframe)))
		return interp_error(interp, "push callframe");

	/*
	if (unlikely(!interp_code(interp))) {
		return interp_error(interp, "call %s:%d",
				get_function_name(interp->module, fn),
				fn);
	}

	if (unlikely(!drop_callframe(interp)))
		return interp_error(interp, "drop callframe");
	*/

	return 1;
}

static INLINE int call_builtin_func(struct wasm_interp *interp, struct func *func)
{
	struct callframe callframe = {};
	struct val *locals;
	int prev_items, res;

	if (!prepare_call(interp, func, &locals, &prev_items))
		return interp_error(interp, "prepare args");

	/* update current function and push it to the callframe as well */
	callframe.func = func;
	callframe.locals = locals;
	callframe.prev_stack_items = prev_items;

	if (unlikely(!push_callframe(interp, &callframe)))
		return interp_error(interp, "oob cursor_pushcode");

    res = func->builtin->fn(interp);
	if (!res)
		return interp_error(interp, "builtin trap");

	if (unlikely(!drop_callframe(interp)))
		return interp_error(interp, "pop callframe");

	return res;
}

static INLINE int call_func(struct wasm_interp *interp, struct func *func)
{
	switch (func->type) {
	case func_type_wasm:
		return call_wasm_func(interp, func);
	case func_type_builtin:
		if (func->builtin == NULL) {
			return interp_error(interp,
					"attempted to call unresolved fn: %s",
					func->name);
		}
		return call_builtin_func(interp, func);
	}
	return interp_error(interp, "corrupt func type: %02x", func->type);
}


static int call_function(struct wasm_interp *interp, int func_index)
{
	struct func *func;

	debug("calling %s:%d\n", get_function_name(interp->module, func_index), func_index);

	if (unlikely(!(func = get_fn(interp->module, func_index)))) {
		return interp_error(interp,
				"function %s (%d) not found (%d funcs)",
				get_function_name(interp->module, func_index),
				func_index,
				interp->module->code_section.num_funcs);
	}

	return call_func(interp, func);
}

static int interp_call(struct wasm_interp *interp, int func_index)
{
	int res;
#ifdef DEBUG
	struct callframe prev_frame;

	assert(top_callframe(&interp->callframes));
	memcpy(&prev_frame, top_callframe(&interp->callframes), sizeof(struct callframe));
#endif

	res = call_function(interp, func_index);
	if (unlikely(!res))
		return 0;

	/*
	debug("returning from %s:%d to %s:%d\n",
			get_function_name(interp->module, func_index),
			func_index,
			get_function_name(interp->module, prev_frame.fn),
			prev_frame.fn);
			*/

	return res;
}

static int interp_call_indirect(struct wasm_interp *interp, struct call_indirect *call)
{
	static char buf[128];
	static char buf2[128];
	struct functype *type;
	struct func *func, pfunc;
	struct table_inst *table;
	struct builtin *builtin;
	struct refval *ref;
	u32 ftidx;
	int i;

	if (unlikely(!was_section_parsed(interp->module, section_table))) {
		return interp_error(interp, "no table section");
	}

	if (unlikely(call->tableidx >= interp->module_inst.num_tables)) {
		return interp_error(interp, "invalid table index %d (max %d)",
				call->tableidx,
				interp->module_inst.num_tables-1);
	}

	if (unlikely(call->typeidx >=
		     interp->module->type_section.num_functypes)) {
		return interp_error(interp, "invalid function type index: %d (max %d)",
			call->typeidx,
			interp->module->type_section.num_functypes);
	}

	table = &interp->module_inst.tables[call->tableidx];
	type = &interp->module->type_section.functypes[call->typeidx];

	if (unlikely(table->reftype != funcref)) {
		return interp_error(interp,
				"table[%d] is not a function reference table",
				call->tableidx
				);
	}

	if (unlikely(!stack_pop_i32(interp, &i))) {
		return interp_error(interp, "pop i32");
	}

	if (unlikely(i < 0 || i >= (int)table->num_refs)) {
		return interp_error(interp, "invalid index %d in table %d (max %d)",
				i, call->tableidx, table->num_refs-1);
	}

	ref = &table->refs[i];

	if (ref->addr == 0) {
		return interp_error(interp, "null ref in index %d of table %d",
				i, call->tableidx);
	}

	// HACKY special case for indirect host builtins
	i = -((int)ref->addr);
	if (-i < 0 && i < interp->num_builtins ) {
		builtin = &interp->builtins[i];
		make_builtin_func(&pfunc, builtin->name, type, builtin, -i);
		debug("calling indirect builtin %s\n", pfunc.name);
		return call_builtin_func(interp, &pfunc);
	}

	func = &interp->module->funcs[ref->addr];

	if (func->functype != type) {
		ftidx = (int)((func->functype - interp->module->type_section.functypes ) / sizeof(struct functype));

		return interp_error(interp,
				"functype mismatch, expected %d `%s`, got %d `%s`",
				ftidx,
				functype_str(func->functype, buf, sizeof(buf)),
				call->typeidx,
				functype_str(type, buf2, sizeof(buf2)),
				ref, interp->module->num_funcs-1);
	}

	debug("calling %s:%d indirectly\n",
			get_function_name(interp->module, ref->addr),
			ref->addr);

	return interp_call(interp, ref->addr);
}

static int parse_blocktype(struct cursor *cur, struct errors *errs, struct blocktype *blocktype)
{
	unsigned char byte;

	if (unlikely(!pull_byte(cur, &byte))) {
		return note_error(errs, cur, "parse_blocktype: oob\n");
	}

	if (byte == 0x40) {
		blocktype->tag = blocktype_empty;
	} else if (is_valtype(byte)) {
		blocktype->tag = blocktype_valtype;
		blocktype->valtype = (enum valtype)byte;
	} else {
		blocktype->tag = blocktype_index;
		cur->p--;

		if (!parse_int(cur, &blocktype->type_index))
			return note_error(errs, cur, "parse_blocktype: read type_index\n");
	}

	return 1;
}

static INLINE struct label *index_label(struct cursor *a, u32 fn, u32 ind)
{
	return index_cursor(a, ((MAX_LABELS * fn) + ind), sizeof(struct label));
}

static INLINE u32 label_instr_pos(struct label *label)
{
	return label->instr_pos & 0x7FFFFFFF;
}

static INLINE int is_label_resolved(struct label *label)
{
	return label->instr_pos & 0x80000000;
}

static struct label *index_frame_label(struct wasm_interp *interp, u32 ind)
{
	struct callframe *frame;

	frame = top_callframe(&interp->callframes);
	if (unlikely(!frame)) {
		interp_error(interp, "no callframe?");
		return NULL;
	}

	return index_label(&interp->labels, frame->func->idx, ind);
}

static INLINE int resolve_label(struct label *label, struct cursor *code)
{
	if (is_label_resolved(label)) {
		return 1;
	}

	label->jump = (u32)(code->p - code->start);
	label->instr_pos |= 0x80000000;

	/*
	debug("resolving label %04x to %04x\n",
			label_instr_pos(label),
			label->jump);
			*/

	return 1;
}

static INLINE struct resolver *top_resolver_stack(struct cursor *stack, int index)
{
    struct resolver *p = (struct resolver*)stack->p;
    p = &p[-(index+1)];
    if (p < (struct resolver*)stack->start)
        return NULL;
    return p;
}

static INLINE struct resolver *top_resolver(struct wasm_interp *interp, u32 index)
{
	return top_resolver_stack(&interp->resolver_stack, index);
}

/*
static void print_resolver_stack(struct wasm_interp *interp) {
	int count, i, start_pos, end_pos;
	struct label *label;

	printf("resolver stack: ");
	count = (int)cursor_count(&interp->resolver_stack, sizeof(struct resolver));

	for (i = 0; i < count; i++) {
		struct resolver *r = top_resolver(interp, i);
		if (i != 0)
			printf(", ");
        
		label = index_frame_label(interp, r->label);
        
		start_pos = label_instr_pos(label);
		end_pos = label->jump;
        
		printf("%s@%d:%s@%d", instr_name(r->start_tag), start_pos, instr_name(r->end_tag), end_pos);
	}
	printf("\n");
}
*/

static INLINE int pop_resolver(struct wasm_interp *interp,
		struct resolver *resolver)
{

#if 0
	int num_resolvers;
	struct label *label;
	debug("pop  label ");
	print_resolver_stack(interp);
#endif

	if (!cursor_pop(&interp->resolver_stack, (u8*)resolver, sizeof(*resolver))) {
		return interp_error(interp, "pop resolver");
	}

#if 0
	if (unlikely(!count_local_resolvers(interp, &num_resolvers))) {
		return interp_error(interp, "local resolvers fn start");
	};

	label = index_label(&interp->labels,
			    top_callframe(&interp->callframes)->func->idx,
			    resolver->label);

	debug("%04lX popped resolver label:%d %04x-%04x i_%s i_%s %d local_resolvers:%d\n",
			interp_codeptr(interp)->p - interp_codeptr(interp)->start,
			resolver->label,
			label_instr_pos(label),
			label->jump,
			instr_name(resolver->start_tag),
			instr_name(resolver->end_tag),
			count_resolvers(interp),
			num_resolvers
			);
#endif
	return 1;
}

static int pop_label(struct wasm_interp *interp,
		struct resolver *resolver,
		struct callframe **frame,
		struct label **label)
{
	if (unlikely(!pop_resolver(interp, resolver)))
		return interp_error(interp, "couldn't pop jump resolver stack");

	if (unlikely(!(*frame = top_callframe(&interp->callframes))))
		return interp_error(interp, "no callframe?");

	if (unlikely(!(*label = index_label(&interp->labels, (*frame)->func->idx,
					    resolver->label))))
		return interp_error(interp, "index label");

	if (unlikely(!resolve_label(*label, &(*frame)->code)))
		return interp_error(interp, "resolve label");

	return 1;
}


static INLINE int pop_label_checkpoint(struct wasm_interp *interp)
{
	struct resolver resolver;
	struct callframe *frame;
	struct label *label;

	return pop_label(interp, &resolver, &frame, &label);
}

static INLINE u16 *func_num_labels(struct wasm_interp *interp, u32 fn)
{
	u16 *num = index_cursor(&interp->num_labels, fn, sizeof(u16));
	assert(num);
	assert(*num <= MAX_LABELS);
	return num;
}

static int find_label(struct wasm_interp *interp, u32 fn, u32 instr_pos)
{
	u16 *num_labels;
	int i;
	struct label *label;

	num_labels = func_num_labels(interp, fn);

	if (!(label = index_label(&interp->labels, fn, *num_labels-1)))
		return interp_error(interp, "index label");

	for (i = *num_labels-1; i >= 0; label--) {
		if (label_instr_pos(label) == instr_pos)
			return i;
		i--;
	}

	return -1;
}

static INLINE void set_label_pos(struct label *label, u32 pos)
{
	assert(!(pos & 0x80000000));
	label->instr_pos = pos;
}

// upsert an unresolved label
static int upsert_label(struct wasm_interp *interp, u32 fn,
			u32 instr_pos, int *ind)
{
	struct label *label;
	u16 *num_labels;

	num_labels = func_num_labels(interp, fn);

	if (*num_labels > 0 && ((*ind = find_label(interp, fn, instr_pos)) != -1)) {
		// we already have the label
		return 1;
	}

	if (*num_labels + 1 >= MAX_LABELS) {
		interp_error(interp, "too many labels in %s (> %d)",
			get_function_name(interp->module, fn), MAX_LABELS);
		return 0;
	}

	/*
	debug("upsert_label: %d labels for %s:%d\n",
	      *num_labels, get_function_name(interp->module, fn), fn);
	      */

	*ind = *num_labels;
	if (unlikely(!(label = index_label(&interp->labels, fn, *ind))))
		return interp_error(interp, "index label");

	set_label_pos(label, instr_pos);
	*num_labels = *num_labels + 1;

	return 2;
}

static INLINE int cursor_push_resolver(struct cursor *stack, struct resolver *resolver)
{
	return cursor_push(stack, (u8*)resolver, sizeof(*resolver));
}

struct tag_info {
	u8 flags;
	u8 end_tag;
};

// when we encounter a control instruction, try to resolve the label, otherwise
// push the label index to the resolver stack for resolution later
static int push_label_checkpoint(struct wasm_interp *interp, struct label **label,
		u8 start_tag, u8 end_tag)
{
	u32 instr_pos, fns;
	int ind;
	struct resolver resolver;
	struct callframe *frame;

#if 0
	int num_resolvers;
	debug("push label ");
	print_resolver_stack(interp);
#endif

	resolver.start_tag = start_tag;
	resolver.end_tag = end_tag;
	resolver.label = 0;

	*label = NULL;

	fns = interp->module->num_funcs;
	frame = top_callframe(&interp->callframes);

	if (unlikely(!frame)) {
		return interp_error(interp, "no callframes available?");
	} else if (unlikely(frame->func->idx >= fns)) {
		return interp_error(interp, "invalid fn index?");
	}

	instr_pos = (int)(frame->code.p - frame->code.start);
	if (unlikely(!upsert_label(interp, frame->func->idx, instr_pos, &ind))) {
		return interp_error(interp, "upsert label");
	}

	if (unlikely(!(*label = index_label(&interp->labels, frame->func->idx, ind)))) {
		return interp_error(interp, "couldn't index label");
	}

	resolver.label = ind;

	if (unlikely(!cursor_push_resolver(&interp->resolver_stack, &resolver))) {
		return interp_error(interp, "push label index to resolver stack oob");
	}

#if 0
	if (unlikely(!count_local_resolvers(interp, &num_resolvers))) {
		return interp_error(interp, "local resolvers fn start");
	};

	debug("%04x pushed resolver label:%d 0x%04X-0x%04X i_%s i_%s %ld local_resolvers:%d \n",
			instr_pos,
			resolver.label,
			label_instr_pos(*label),
			(*label)->jump,
			instr_name(resolver.start_tag),
			instr_name(resolver.end_tag),
			cursor_count(&interp->resolver_stack, sizeof(resolver)),
			num_resolvers);
#endif

	return 1;
}

static int interp_jump(struct wasm_interp *interp, int jmp)
{
	struct callframe *frame;

	frame = top_callframe(&interp->callframes);
	if (unlikely(!frame)) {
		return interp_error(interp, "no callframe?");
	}

	debug("jumping to %04x\n", jmp);
	frame->code.p = frame->code.start + jmp;

	if (unlikely(frame->code.p >= frame->code.end)) {
		return interp_error(interp,
			"code pointer at or past end, evil jump?");
	}

	return 1;
}


static int pop_label_and_skip(struct wasm_interp *interp, struct label *label,
		int times)
{
	int i;
	struct resolver resolver;
	assert(is_label_resolved(label));

	for (i = 0; i < times; i++) {
		if (!pop_resolver(interp, &resolver)) {
			return interp_error(interp, "top resolver");
		}
	}

	return interp_jump(interp, label->jump);
}

static int unresolved_break(struct wasm_interp *interp, int index);

static int break_if(struct wasm_interp *interp, struct label *label)
{
	struct cursor *code;
	struct label *else_label;
	struct expr_parser parser;
	struct expr expr;

	if (!interp_jump(interp, label->jump))
		return interp_error(interp, "if break failed");

	if (!(code = interp_codeptr(interp)))
		return interp_error(interp, "if break codeptr");

	if (code->p - 1 < code->start)
		return interp_error(interp, "oob");

	if (*(code->p - 1) != i_else)
		return 1;

	if (!push_label_checkpoint(interp, &else_label, i_else, i_end))
		return interp_error(interp, "push else label");

	if (is_label_resolved(else_label))
		return pop_label_and_skip(interp, else_label, 1);

	make_interp_expr_parser(interp, &parser);

	if (!parse_instrs_until(&parser, i_end, &expr))
		return interp_error(interp, "skip else instrs");

	if (!pop_label_checkpoint(interp))
		return interp_error(interp, "op else skip");

	return 1;
}


static int break_label(struct wasm_interp *interp, struct resolver *resolver,
		struct label *label)
{

	// we have a loop, push the popped resolver
	if (resolver->start_tag == i_loop) {
		//debug("repushing resolver for loop\n");
		if (unlikely(!cursor_push_resolver(&interp->resolver_stack, resolver))) {
			return interp_error(interp, "re-push loop resolver");
		}

		// loop jump
		return interp_jump(interp, label_instr_pos(label));

	} else if (resolver->start_tag == i_if) {
		return break_if(interp, label);
	}

	return interp_jump(interp, label->jump);
}

static int pop_label_and_break(struct wasm_interp *interp, int times)
{
	int i;
	struct resolver resolver;
	struct label *label;
	struct callframe *frame;

	if (unlikely(times == 0))
		return interp_error(interp, "can't pop label 0 times");

    label = NULL;
	for (i = 0; i < times; i++) {
		if (!pop_label(interp, &resolver, &frame, &label)) {
			return interp_error(interp, "pop resolver");
		}
	}

	return break_label(interp, &resolver, label);
}

static int parse_block_instrs_at(struct expr_parser *p,
		struct expr *exprs, u8 start_tag, u8 end_tag, u8 *stopped_at)
{
	struct label *label = NULL;

	// if we don't have an interpreter instance, we don't care about
	// label resolution (NOT TRUE ANYMORE!)
	if (p->interp && !push_label_checkpoint(p->interp, &label, start_tag,
						end_tag)) {
		return note_error(p->errs, p->code, "push checkpoint");
	}

	if (label && is_label_resolved(label)) {
		debug("label is resolved, skipping block parse\n");
		// TODO verify this is correct
		exprs->code     = p->code->start + label_instr_pos(label);
		exprs->code_len = (int)((p->code->start + label->jump) - exprs->code);

		return pop_label_and_skip(p->interp, label, 1);
	}

	if (!parse_instrs_until_at(p, end_tag, exprs, stopped_at))
		return note_error(p->errs, p->code, "parse instrs");

	if (!pop_label_checkpoint(p->interp))
		return note_error(p->errs, p->code, "pop label");

	return 1;

}

static INLINE int parse_block_instrs(struct expr_parser *p, struct expr *exprs,
			      u8 start_tag, u8 end_tag)
{
	u8 stopped_at;
	return parse_block_instrs_at(p, exprs, start_tag, end_tag, &stopped_at);
}

static int parse_block_at(struct expr_parser *p, struct block *block, u8 start_tag,
		u8 end_tag, u8 *stopped_at)
{
	if (!parse_blocktype(p->code, p->errs, &block->type))
		return note_error(p->errs, p->code, "blocktype");

	if (!parse_block_instrs_at(p, &block->instrs, start_tag, end_tag,
				stopped_at))
		return note_error(p->errs, p->code, "block instrs");

	debug("%04lX parse block ended\n",
			p->interp ? p->code->p - p->code->start : 0L);

	return 1;
}

static INLINE int parse_block(struct expr_parser *p, struct block *block,
		u8 start_tag, u8 end_tag)
{
	u8 stopped_at;
	return parse_block_at(p, block, start_tag, end_tag, &stopped_at);
}

static INLINE int parse_else(struct expr_parser *p, struct expr *instrs)
{
	if (p->interp && !pop_label_checkpoint(p->interp))
		return note_error(p->errs, p->code, "pop if checkpoint");

	debug("parsing else...\n");
	return parse_block_instrs(p, instrs, i_else, i_end);
}

static INLINE int parse_memarg(struct cursor *code, struct memarg *memarg)
{
	return parse_u32(code, &memarg->align) &&
	       parse_u32(code, &memarg->offset);
}

static int parse_call_indirect(struct cursor *code,
		struct call_indirect *call_indirect)
{
	return parse_u32(code, &call_indirect->typeidx) &&
	       parse_u32(code, &call_indirect->tableidx);
}

static int parse_bulk_op(struct cursor *code, struct errors *errs,
		struct bulk_op *bulk_op)
{
	u8 tag;

	if (unlikely(!pull_byte(code, &tag)))
		return note_error(errs, code, "oob");

	if (unlikely(tag < 10 || tag > 17))
		return note_error(errs, code, "invalid bulk op %d", tag);

	bulk_op->tag = tag;

	switch ((enum bulk_tag)tag) {
	case i_memory_copy:
		if (unlikely(!consume_byte(code, 0)))
			return note_error(errs, code, "mem idx dst 0");
		if (unlikely(!consume_byte(code, 0)))
			return note_error(errs, code, "mem idx src 0");
		return 1;

	case i_memory_fill:
		if (unlikely(!consume_byte(code, 0)))
			return note_error(errs, code, "mem idx 0");
		return 1;

	case i_table_init:
		if (unlikely(!parse_u32(code, &bulk_op->table_init.elemidx)))
			return note_error(errs, code, "elemidx");
		if (unlikely(!parse_u32(code, &bulk_op->table_init.tableidx)))
			return note_error(errs, code, "tableidx");
		return 1;

	case i_elem_drop:
		if (unlikely(!parse_u32(code, &bulk_op->idx)))
			return note_error(errs, code, "elemidx");
		return 1;

	case i_table_copy:
		if (unlikely(!parse_u32(code, &bulk_op->table_copy.from)))
			return note_error(errs, code, "elemidx");
		if (unlikely(!parse_u32(code, &bulk_op->table_copy.to)))
			return note_error(errs, code, "tableidx");
		return 1;

	case i_table_grow:
	case i_table_size:
	case i_table_fill:
		if (unlikely(!parse_u32(code, &bulk_op->idx)))
			return note_error(errs, code, "tableidx");
		return 1;
	}

	return note_error(errs, code, "unhandled table op 0x%02x", tag);
}

static int parse_br_table(struct cursor *code, struct errors *errs,
		struct br_table *br_table)
{
	u32 i;

	if (unlikely(!parse_u32(code, &br_table->num_label_indices))) {
		return note_error(errs, code, "fail read br_table num_indices");
	}

	if (br_table->num_label_indices > ARRAY_SIZE(br_table->label_indices)) {
		return note_error(errs, code, "whoa slow down on that one chief. "
			"This br_table has %d indices but we only have room "
			"in our tiny struct for %d indices",
			br_table->num_label_indices,
			ARRAY_SIZE(br_table->label_indices));
	}

	for (i = 0; i < br_table->num_label_indices; i++) {
		if (unlikely(!parse_u32(code, &br_table->label_indices[i]))) {
			return note_error(errs, code,
					  "failed to read br_table label %d/%d",
					  i+1, br_table->num_label_indices);
		}
	}

	if (unlikely(!parse_u32(code, &br_table->default_label))) {
		return note_error(errs, code, "failed to parse default label");
	}

	return 1;
}

static int parse_select(struct cursor *code, struct errors *errs, u8 tag,
		struct select_instr *select)
{
	if (tag == i_select) {
		select->num_valtypes = 0;
		select->valtypes = NULL;
		return 1;
	}

	if (unlikely(!parse_u32(code, &select->num_valtypes))) {
		return note_error(errs, code,
				"couldn't parse select valtype vec count");
	}

	select->valtypes = code->p;
	code->p += select->num_valtypes;

	return 1;
}

static int parse_if(struct expr_parser *p, struct block *block)
{
	struct label *label;
	struct expr expr;
	u8 stopped_at;

	if (!parse_block_at(p, block, i_if, i_if, &stopped_at))
		return note_error(p->errs, p->code, "parse if block");

	if (p->interp == NULL || stopped_at != i_else)
		return 1;

	// else
	if (!push_label_checkpoint(p->interp, &label, i_else, i_end))
		return note_error(p->errs, p->code, "push else checkpoint");

	if (is_label_resolved(label))
		return pop_label_and_skip(p->interp, label, 1);

	if (!parse_instrs_until(p, i_end, &expr))
		return note_error(p->errs, p->code, "parse else instrs");

	if (!pop_label_checkpoint(p->interp))
		return note_error(p->errs, p->code, "pop else checkpoint");

	return 1;
}

static int parse_instr(struct expr_parser *p, u8 tag, struct instr *op)
{
	op->pos = (int)(p->code->p - 1 - p->code->start);
	op->tag = tag;

	switch ((enum instr_tag)tag) {
		// two-byte instrs
		case i_select:
		case i_selects:
			return parse_select(p->code, p->errs, tag, &op->select);

		case i_memory_size:
		case i_memory_grow:
			return consume_byte(p->code, 0);

		case i_block:
			return parse_block(p, &op->block, i_block, i_end);
		case i_loop:
			return parse_block(p, &op->block, i_loop, i_end);
		case i_if:
			return parse_if(p, &op->block);
		case i_else:
			return parse_else(p, &op->else_block);

		case i_call:
		case i_local_get:
		case i_local_set:
		case i_local_tee:
		case i_global_get:
		case i_global_set:
		case i_br:
		case i_br_if:
		case i_ref_func:
		case i_table_set:
		case i_table_get:
			if (unlikely(!parse_u32(p->code, &op->u32))) {
				return note_error(p->errs, p->code,
						"couldn't read int");
			}
			return 1;

		case i_i32_const:
			if (unlikely(!parse_int(p->code, &op->i32))) {
				return note_error(p->errs, p->code,
						"couldn't read int");
			}
			return 1;

		case i_i64_const:
			if (unlikely(!parse_i64(p->code, &op->u64))) {
				return note_error(p->errs, p->code,
						"couldn't read i64");
			}
			return 1;

		case i_ref_is_null:
		case i_i32_load:
		case i_i64_load:
		case i_f32_load:
		case i_f64_load:
		case i_i32_load8_s:
		case i_i32_load8_u:
		case i_i32_load16_s:
		case i_i32_load16_u:
		case i_i64_load8_s:
		case i_i64_load8_u:
		case i_i64_load16_s:
		case i_i64_load16_u:
		case i_i64_load32_s:
		case i_i64_load32_u:
		case i_i32_store:
		case i_i64_store:
		case i_f32_store:
		case i_f64_store:
		case i_i32_store8:
		case i_i32_store16:
		case i_i64_store8:
		case i_i64_store16:
		case i_i64_store32:
			return parse_memarg(p->code, &op->memarg);

		case i_br_table:
			return parse_br_table(p->code, p->errs, &op->br_table);

		case i_bulk_op:
			return parse_bulk_op(p->code, p->errs, &op->bulk_op);

		case i_call_indirect:
			return parse_call_indirect(p->code, &op->call_indirect);

		case i_f32_const:
			return read_f32(p->code, &op->f32);

		case i_f64_const:
			return read_f64(p->code, &op->f64);

		// single-tag ops
		case i_end:
		case i_ref_null:
		case i_unreachable:
		case i_nop:
		case i_return:
		case i_drop:
		case i_i32_eqz:
		case i_i32_eq:
		case i_i32_ne:
		case i_i32_lt_s:
		case i_i32_lt_u:
		case i_i32_gt_s:
		case i_i32_gt_u:
		case i_i32_le_s:
		case i_i32_le_u:
		case i_i32_ge_s:
		case i_i32_ge_u:
		case i_i64_eqz:
		case i_i64_eq:
		case i_i64_ne:
		case i_i64_lt_s:
		case i_i64_lt_u:
		case i_i64_gt_s:
		case i_i64_gt_u:
		case i_i64_le_s:
		case i_i64_le_u:
		case i_i64_ge_s:
		case i_i64_ge_u:
		case i_f32_eq:
		case i_f32_ne:
		case i_f32_lt:
		case i_f32_gt:
		case i_f32_le:
		case i_f32_ge:
		case i_f64_eq:
		case i_f64_ne:
		case i_f64_lt:
		case i_f64_gt:
		case i_f64_le:
		case i_f64_ge:
		case i_i32_clz:
		case i_i32_ctz:
		case i_i32_popcnt:
		case i_i32_add:
		case i_i32_sub:
		case i_i32_mul:
		case i_i32_div_s:
		case i_i32_div_u:
		case i_i32_rem_s:
		case i_i32_rem_u:
		case i_i32_and:
		case i_i32_or:
		case i_i32_xor:
		case i_i32_shl:
		case i_i32_shr_s:
		case i_i32_shr_u:
		case i_i32_rotl:
		case i_i32_rotr:
		case i_i64_clz:
		case i_i64_ctz:
		case i_i64_popcnt:
		case i_i64_add:
		case i_i64_sub:
		case i_i64_mul:
		case i_i64_div_s:
		case i_i64_div_u:
		case i_i64_rem_s:
		case i_i64_rem_u:
		case i_i64_and:
		case i_i64_or:
		case i_i64_xor:
		case i_i64_shl:
		case i_i64_shr_s:
		case i_i64_shr_u:
		case i_i64_rotl:
		case i_i64_rotr:
		case i_f32_abs:
		case i_f32_neg:
		case i_f32_ceil:
		case i_f32_floor:
		case i_f32_trunc:
		case i_f32_nearest:
		case i_f32_sqrt:
		case i_f32_add:
		case i_f32_sub:
		case i_f32_mul:
		case i_f32_div:
		case i_f32_min:
		case i_f32_max:
		case i_f32_copysign:
		case i_f64_abs:
		case i_f64_neg:
		case i_f64_ceil:
		case i_f64_floor:
		case i_f64_trunc:
		case i_f64_nearest:
		case i_f64_sqrt:
		case i_f64_add:
		case i_f64_sub:
		case i_f64_mul:
		case i_f64_div:
		case i_f64_min:
		case i_f64_max:
		case i_f64_copysign:
		case i_i32_wrap_i64:
		case i_i32_trunc_f32_s:
		case i_i32_trunc_f32_u:
		case i_i32_trunc_f64_s:
		case i_i32_trunc_f64_u:
		case i_i64_extend_i32_s:
		case i_i64_extend_i32_u:
		case i_i64_trunc_f32_s:
		case i_i64_trunc_f32_u:
		case i_i64_trunc_f64_s:
		case i_i64_trunc_f64_u:
		case i_f32_convert_i32_s:
		case i_f32_convert_i32_u:
		case i_f32_convert_i64_s:
		case i_f32_convert_i64_u:
		case i_f32_demote_f64:
		case i_f64_convert_i32_s:
		case i_f64_convert_i32_u:
		case i_f64_convert_i64_s:
		case i_f64_convert_i64_u:
		case i_f64_promote_f32:
		case i_i32_reinterpret_f32:
		case i_i64_reinterpret_f64:
		case i_f32_reinterpret_i32:
		case i_f64_reinterpret_i64:
		case i_i32_extend8_s:
		case i_i32_extend16_s:
		case i_i64_extend8_s:
		case i_i64_extend16_s:
		case i_i64_extend32_s:
			return 1;
	}

	return note_error(p->errs, p->code, "unhandled tag: 0x%x", tag);
}

// end or else
static int if_jump(struct wasm_interp *interp, struct label *label)
{
	struct expr expr;
	struct expr_parser parser;
	struct label *else_label;
    struct cursor *codeptr;
	u8 stopped_at;

	if (!label) {
		return interp_error(interp, "no label?");
	}

	if (is_label_resolved(label)) {
		//debug("if_jump resolved label ");
		//print_resolver_stack(interp);
		if (!pop_label_and_skip(interp, label, 1))
			return interp_error(interp, "pop if after resolved jump");
		if (!(codeptr = interp_codeptr(interp)) && codeptr->p - 1 >= codeptr->start)
			return interp_error(interp, "codeptr looking for else");
		stopped_at = *(codeptr->p-1);
		if (stopped_at == i_else && !push_label_checkpoint(interp, &else_label, i_else, i_end))
			return interp_error(interp, "push else label");
		return 1;
	}

	make_interp_expr_parser(interp, &parser);

	// consume instructions, use resolver stack to resolve jumps
	if (!parse_instrs_until_at(&parser, i_if, &expr, &stopped_at))
		return interp_error(interp, "parse instrs start (if)");

	if (!pop_label_checkpoint(interp))
		return interp_error(interp, "pop label");

	if (stopped_at == i_else && !push_label_checkpoint(interp, &else_label,
							   i_else, i_end)) {
		return interp_error(interp, "push else label");
	}

	debug("%04lX if_jump ended\n",
		parser.code->p - parser.code->start);

	return 1;
}

static int interp_block(struct wasm_interp *interp)
{
	struct cursor *code;
	struct label *label;
	struct blocktype blocktype;

	if (unlikely(!(code = interp_codeptr(interp))))
		return interp_error(interp, "empty callstack?");

	if (unlikely(!parse_blocktype(code, &interp->errors, &blocktype)))
		return interp_error(interp, "couldn't parse blocktype");

	if (unlikely(!push_label_checkpoint(interp, &label, i_block, i_end)))
		return interp_error(interp, "block label checkpoint");

	return 1;
}

static INLINE struct label *top_label(struct wasm_interp *interp, u32 index)
{
	struct resolver *resolver;

	if (unlikely(!(resolver = top_resolver(interp, index)))) {
		interp_error(interp, "invalid resolver index %d", index);
		return NULL;
	}

	return index_frame_label(interp, resolver->label);
}

static INLINE int interp_else(struct wasm_interp *interp)
{
	(void)interp;
	/*
	struct label *label;
	struct expr expr;
	struct expr_parser parser;

	if (!(label = top_label(interp, 0)))
		return interp_error(interp, "no label?");

	if (!push_label_checkpoint(interp, &label, i_else, i_end)) {
		return interp_error(interp, "label checkpoint");
	}

	if (!is_label_resolved(label)) {
		return interp_error(interp, "expected label to be parsed");
	}
	*/

	return 1;
}

static int interp_if(struct wasm_interp *interp)
{
	struct val cond;
	struct blocktype blocktype;
	struct cursor *code;
	struct label *label;

	if (unlikely(!(code = interp_codeptr(interp)))) {
		return interp_error(interp, "empty callstack?");
	}

	if (unlikely(!parse_blocktype(code, &interp->errors, &blocktype))) {
		return interp_error(interp, "couldn't parse blocktype");
	}

	if (unlikely(!cursor_popval(&interp->stack, &cond))) {
		return interp_error(interp, "if pop val");
	}

	if (!push_label_checkpoint(interp, &label, i_if, i_if)) {
		return interp_error(interp, "label checkpoint");
	}

	if (cond.num.i32 != 0) {
		return 1;
	}

	if (unlikely(!if_jump(interp, label))) {
		return interp_error(interp, "jump");
	}

	return 1;
}

static INLINE int clz32(u32 x)
{
	return x ? __builtin_clz(x) : sizeof(x) * 8;
}

static INLINE int clz64(u64 x)
{
	return x ? __builtin_clzll(x) : sizeof(x) * 8;
}

static INLINE int ctz(u32 x)
{
	return x ? __builtin_ctz(x) : (int)sizeof(x) * 8;
}

static INLINE int popcnt(u32 x)
{
	return x ? __builtin_popcount(x) : 0;
}

static INLINE int interp_i32_popcnt(struct wasm_interp *interp)
{
	struct val a;
	if (unlikely(!stack_pop_valtype(interp, val_i32, &a)))
		return interp_error(interp, "pop val");
	return stack_push_i32(interp, popcnt(a.num.u32));
}

static INLINE int interp_i32_ctz(struct wasm_interp *interp)
{
	struct val a;
	if (unlikely(!stack_pop_valtype(interp, val_i32, &a)))
		return interp_error(interp, "pop val");
	return stack_push_i32(interp, ctz(a.num.u32));
}

static INLINE int interp_i64_clz(struct wasm_interp *interp)
{
	struct val a;
	if (unlikely(!stack_pop_valtype(interp, val_i64, &a)))
		return interp_error(interp, "pop val");
	return stack_push_i64(interp, clz64(a.num.u64));
}

static INLINE int interp_i32_clz(struct wasm_interp *interp)
{
	struct val a;
	if (unlikely(!stack_pop_valtype(interp, val_i32, &a)))
		return interp_error(interp, "pop val");
	return stack_push_i32(interp, clz32(a.num.u32));
}

static INLINE int interp_i32_eqz(struct wasm_interp *interp)
{
	struct val a;
	if (unlikely(!stack_pop_valtype(interp, val_i32, &a)))
		return interp_error(interp, "pop val");
	return stack_push_i32(interp, a.num.i32 == 0);
}

static int unresolved_break(struct wasm_interp *interp, int index)
{
	struct expr_parser parser;
	struct callframe *frame;
	struct expr expr;

	struct resolver *resolver = NULL;
	struct label *label = NULL;

#if DEBUG
	int times;
#endif

	make_interp_expr_parser(interp, &parser);

	if (unlikely(!(frame = top_callframe(&interp->callframes)))) {
		return interp_error(interp, "no top callframe?");
	}


#if DEBUG
	times = index+1;
#endif
	debug("breaking %d times from unresolved label\n", times);

	while (index-- >= 0) {
		if (unlikely(!(resolver = top_resolver(interp, 0)))) {
			return interp_error(interp, "invalid resolver index %d",
					index);
		}

		if (unlikely(!(label = index_frame_label(interp, resolver->label)))) {
			return interp_error(interp, "no label");
		}

		// TODO: breaking from functions (return)
		if (is_label_resolved(label)) {
			if (index == -1)
				return pop_label_and_break(interp, 1);
			else if (!pop_label_and_skip(interp, label, 1))
				return interp_error(interp, "pop and jump");
			else
				continue;
		}

		if (unlikely(!parse_instrs_until(&parser, resolver->end_tag, &expr)))
			return interp_error(interp, "parsing instrs");

		if (index == -1)
			return pop_label_and_break(interp, 1);

		if (!pop_label_checkpoint(interp))
			return interp_error(interp, "pop label");
	}

	/*
	debug("finished breaking %d times from unresolved label (it was a %s)\n",
			times,
			instr_name(resolver->start_tag));

	assert(resolver);
	assert(label);

	if (resolver->start_tag == i_loop) {
		debug("jumping to start of loop\n");
		if (unlikely(!cursor_push_resolver(&interp->resolver_stack,
						   resolver))) {
			return interp_error(interp, "re-push loop resolver");
		}
		return interp_jump(interp, label_instr_pos(label));
	}

	*/
	return interp_error(interp, "shouldn't get here");
}

static int interp_return(struct wasm_interp *interp)
{
	int count;

	if (unlikely(!count_local_resolvers(interp, &count))) {
		return interp_error(interp, "failed to count fn labels?");
	}

	if (unlikely(!cursor_dropn(&interp->resolver_stack,
					sizeof(struct resolver), count))) {
		return interp_error(interp, "failed to drop %d local labels",
				count);
	}

	return drop_callframe_return(interp, 1);
}


static int interp_br_jump(struct wasm_interp *interp, u32 index)
{
	struct label *label;

	if (unlikely(!(label = top_label(interp, index)))) {
		//print_resolver_stack(interp);
		return interp_return(interp);
	}

	if (is_label_resolved(label)) {
		return pop_label_and_break(interp, index+1);
	}

	return unresolved_break(interp, index);
}

static INLINE int interp_br(struct wasm_interp *interp, u32 ind)
{
	return interp_br_jump(interp, ind);
}

static INLINE int interp_br_table(struct wasm_interp *interp,
				  struct br_table *br_table)
{
	int i;

	if (!stack_pop_i32(interp, &i)) {
		return interp_error(interp, "pop br_table index");
	}

	if ((u32)i < br_table->num_label_indices) {
		return interp_br_jump(interp, br_table->label_indices[i]);
	}

	return interp_br_jump(interp, br_table->default_label);
}

static INLINE int interp_br_if(struct wasm_interp *interp, u32 ind)
{
	int cond = 0;

	// TODO: can this be something other than an i32?
	if (unlikely(!stack_pop_i32(interp, &cond))) {
		return interp_error(interp, "pop br_if i32");
	}

	if (cond != 0)
		return interp_br_jump(interp, ind);

	return 1;
}

static struct val *get_global_inst(struct wasm_interp *interp, u32 ind)
{
	struct global_inst *global_inst;

	if (unlikely(!was_section_parsed(interp->module, section_global))) {
		interp_error(interp,
			"can't get global %d, no global section parsed!", ind);
		return NULL;
	}

	if (unlikely(ind >= interp->module_inst.num_globals)) {
		interp_error(interp, "invalid global index %d (max %d)", ind,
			     interp->module_inst.num_globals);
		return NULL;
	}

	global_inst = &interp->module_inst.globals[ind];

	/* copy initialized global from module to global instance */
	//memcpy(&global_inst->val, &global->val, sizeof(global_inst->val));

	return &global_inst->val;
}

static int interp_global_get(struct wasm_interp *interp, u32 ind)
{
	struct globalsec *section = &interp->module->global_section;
	struct val *global;

	// TODO imported global indices?
	if (unlikely(ind >= section->num_globals)) {
		return interp_error(interp, "invalid global index %d / %d",
				ind, section->num_globals-1);
	}

	if (!(global = get_global_inst(interp, ind))) {
		return interp_error(interp, "get global");
	}

	return stack_pushval(interp, global);
}

static INLINE int has_memory_section(struct module *module)
{
	return was_section_parsed(module, section_memory) &&
		module->memory_section.num_mems > 0;
}

static INLINE int bitwidth(enum valtype vt)
{
	switch (vt) {
	case val_i32:
	case val_f32:
		return 32;

	case val_i64:
	case val_f64:
		return 64;

	/* invalid? */
	case val_ref_null:
	case val_ref_func:
	case val_ref_extern:
		return 0;
	}

	return 0;
}

struct memtarget {
	int size;
	u8 *pos;
};

static int interp_mem_offset(struct wasm_interp *interp,
		int *N, int i, enum valtype c, struct memarg *memarg,
		struct memtarget *t)
{
	int offset, bw;

	if (unlikely(!has_memory_section(interp->module))) {
		return interp_error(interp, "no memory section");
	}

	offset = i + memarg->offset;
	bw = bitwidth(c);

	if (*N == 0) {
		*N = bw;
	}

	t->size = *N/8;
	t->pos = interp->memory.start + offset;

	if (t->pos < interp->memory.start) {
		return interp_error(interp,
				"invalid memory offset %d\n", offset);
	}

	if (t->pos + t->size > interp->memory.p) {
		return interp_error(interp,
			"mem store oob pos:%d size:%d mem:%d", offset, t->size,
				interp->memory.p - interp->memory.start);
	}

	return 1;
}

static int wrap_val(struct val *val, unsigned int size) {
	switch (val->type) {
	case val_i32:
		if (size == 32)
			return 1;
		//debug("before %d size %d (mask %lx)\n", val->num.i32, size, (1UL << size)-1);
		val->num.i32 &= (1UL << size)-1;
		//debug("after %d size %d (mask %lx)\n", val->num.i32, size, (1UL << size)-1);
		break;
	case val_i64:
		if (size == 64)
			return 1;
		val->num.i64 &= (1ULL << size)-1;
		break;
	case val_f32:
	case val_f64:
		return 1;

	default:
		return 0;
	}
	return 1;
}

static int store_val(struct wasm_interp *interp, int i,
		struct memarg *memarg, enum valtype type, struct val *val, int N)
{
	struct memtarget target;
	//struct cursor mem;

	if (unlikely(!interp_mem_offset(interp, &N, i, type, memarg, &target)))
		return 0;

	if (N != 0) {
		if (!wrap_val(val, N)) {
			return interp_error(interp,
				"implement wrap val (truncate?) for %s",
				valtype_name(val->type));
		}
	}

	//make_cursor(target.pos, interp->memory.p, &mem);

	debug("storing ");
#ifdef DEBUG
	print_val(val);
#endif 
	debug(" at %ld (%d bytes), N:%d\n", 
			target.pos - interp->memory.start,
			target.size, N);

	//cursor_print_around(&mem, 20);

	memcpy(target.pos, &val->num.i32, target.size);

	return 1;
}

/*
static INLINE int store_simple(struct wasm_interp *interp, int offset, struct val *val)
{
	struct memarg memarg = {};
	return store_val(interp, offset, &memarg, val->type, val, 0);
}

static INLINE int store_i32(struct wasm_interp *interp, int offset, int i)
{
	struct val val;
	make_i32_val(&val, i);
	return store_simple(interp, offset, &val);
}
 */

static int interp_load(struct wasm_interp *interp, struct memarg *memarg,
		enum valtype type, int N, int sign)
{
	struct memtarget target;
//	struct cursor mem;
	struct val out = {0};
	int i;

	(void)sign;

	out.type = type;

	if (unlikely(!stack_pop_i32(interp, &i)))  {
		return interp_error(interp, "pop stack");
	}

	if (unlikely(!interp_mem_offset(interp, &N, i, type, memarg, &target))) {
		return interp_error(interp, "memory target");
	}

	memcpy(&out.num.i32, target.pos, target.size);
	wrap_val(&out, target.size * 8);

	//make_cursor(target.pos, interp->memory.p, &mem);
	debug("loading %d from %ld (copying %d bytes)\n", out.num.i32,
			target.pos - interp->memory.start, target.size);
	//cursor_print_around(&mem, 20);

	if (unlikely(!stack_pushval(interp, &out))) {
		return interp_error(interp,
			"push to stack after load %s", valtype_name(type));
	}

	return 1;
}

/*
static INLINE int load_i32(struct wasm_interp *interp, int addr, int *i)
{
	struct memarg memarg = { .offset = 0, .align = 0 };

	if (unlikely(!stack_push_i32(interp, addr)))
		return interp_error(interp, "push addr %d", addr);

	if (unlikely(!interp_load(interp, &memarg, val_i32, 0, -1)))
		return interp_error(interp, "load");

	return stack_pop_i32(interp, i);
}

static int wasi_fd_close(struct wasm_interp *interp)
{
	struct val *params = NULL;
	if (!get_params(interp, &params, 1))
		return interp_error(interp, "param");

	close(params[0].num.i32);

	return stack_push_i32(interp, 0);
}

static int wasi_fd_write(struct wasm_interp *interp)
{
	struct val *fd, *iovs_ptr, *iovs_len, *written;
	int i, ind, iovec_data, str_len, wrote, all;

	if (unlikely(!(fd = get_local(interp, 0))))
		return interp_error(interp, "fd");

	if (unlikely(!(iovs_ptr = get_local(interp, 1))))
		return interp_error(interp, "iovs_ptr");

	if (unlikely(!(iovs_len = get_local(interp, 2))))
		return interp_error(interp, "iovs_len");

	if (unlikely(!(written = get_local(interp, 3))))
		return interp_error(interp, "written");

	if (unlikely(fd->num.i32 >= 10))
		return interp_error(interp, "weird fd %d", fd->num.i32);

	all = 0;
	str_len = 0;
	i = 0;
	iovec_data = 0;

	for (; i < iovs_len->num.i32; i++) {
		ind = 8*i;

		if (unlikely(!load_i32(interp, iovs_ptr->num.i32 + ind,
				       &iovec_data))) {
			return interp_error(interp, "load iovec data");
		}

		if (unlikely(!load_i32(interp,iovs_ptr->num.i32 + (ind+4),
				       &str_len))) {
			return interp_error(interp, "load iovec data");
		}

		if (unlikely(interp->memory.start + iovec_data + str_len >=
				interp->memory.p)) {
			return interp_error(interp, "fd_write oob");
		}

		debug("fd_write #iovec %d/%d len %d '%.*s'\n",
				i+1,
				iovs_len->num.i32,
				str_len,
				str_len,
				interp->memory.start + iovec_data);

		wrote = (int)write(fd->num.i32, interp->memory.start + iovec_data, str_len );

		all += wrote;

		if (wrote != str_len) {
			return interp_error(interp, "written %d != %d",
					written->num.i32, str_len);
		}
	}

	if (!store_i32(interp, written->num.i32, all)) {
		return interp_error(interp, "store written");
	}

	return stack_push_i32(interp, 0);
}

static int wasi_get_strs(struct wasm_interp *interp, int count, const char **strs)
{
	struct val *argv, *argv_buf;
	struct cursor writer;
	int i, len;

	if (!(argv = get_local(interp, 0)))
		return interp_error(interp, "strs");

	if (!(argv_buf = get_local(interp, 1)))
		return interp_error(interp, "strs_buf");

	make_cursor(interp->memory.start + argv_buf->num.i32,
		    interp->memory.p, &writer);

	for (i = 0; i < count; i++) {
		if (!store_i32(interp, argv->num.i32 + i*4,
			       (int)(writer.p - interp->memory.start))) {
			return interp_error(interp, "store argv %d ptr\n", i);
		}

		len = (int)strlen(strs[i]) + 1;

//		debug("get_str %d '%.*s'\n", i, len, strs[i]);

		if (!cursor_push(&writer, (u8*)strs[i], len)) {
			return interp_error(interp,"write arg %d", i+1);
		}
	}

	return stack_push_i32(interp, 0);

}

static int wasi_strs_sizes_get(struct wasm_interp *interp, int count,
		const char **strs)
{
	struct val *argc_addr, *argv_buf_size_addr;
	int i, size = 0;

	if (!(argc_addr = get_local(interp, 0)))
		return interp_error(interp, "strs count");

	if (!(argv_buf_size_addr = get_local(interp, 1)))
		return interp_error(interp, "strs buf_size");

	if (!store_i32(interp, argc_addr->num.i32, count))
		return interp_error(interp, "store argc");

	for (i = 0; i < count; i++)
		size += strlen(strs[i])+1;

	if (!store_i32(interp, argv_buf_size_addr->num.i32, size)) {
		return interp_error(interp, "store strs size");
	}

	return stack_push_i32(interp, 0);
}

static int wasi_args_get(struct wasm_interp *interp)
{
	return wasi_get_strs(interp, interp->wasi.argc, interp->wasi.argv);
}

static int wasi_environ_get(struct wasm_interp *interp)
{
	return wasi_get_strs(interp, interp->wasi.environc,
			interp->wasi.environ);
}

static int wasi_args_sizes_get(struct wasm_interp *interp)
{
	return wasi_strs_sizes_get(interp, interp->wasi.argc,
			interp->wasi.argv);
}

static int wasi_environ_sizes_get(struct wasm_interp *interp)
{
	return wasi_strs_sizes_get(interp, interp->wasi.environc,
			interp->wasi.environ);
}
 */


static int interp_store(struct wasm_interp *interp, struct memarg *memarg,
		enum valtype type, int N)
{
	struct val c;
	int i;

	if (unlikely(!stack_pop_valtype(interp, type, &c)))  {
		return interp_error(interp, "pop stack");
	}

	if (unlikely(!stack_pop_i32(interp, &i)))  {
		return interp_error(interp, "pop stack");
	}

	return store_val(interp, i, memarg, type, &c, N);
}


static INLINE int interp_global_set(struct wasm_interp *interp, int global_ind)
{
	struct val *global, setval;

	if (unlikely(!(global = get_global_inst(interp, global_ind)))) {
		return interp_error(interp, "couldn't get global %d", global_ind);
	}

	if (unlikely(!stack_popval(interp, &setval))) {
		return interp_error(interp, "couldn't pop stack value");
	}

	memcpy(global, &setval, sizeof(setval));

	return 1;
}

static INLINE int active_pages(struct wasm_interp *interp)
{
	return (int)cursor_count(&interp->memory, WASM_PAGE_SIZE);
}

static int interp_memory_grow(struct wasm_interp *interp, u8 memidx)
{
	int pages = 0, prev_size, grow;

	(void)memidx;

	if (unlikely(!has_memory_section(interp->module))) {
		return interp_error(interp, "no memory section");
	}

	if (!stack_pop_i32(interp, &pages)) {
		return interp_error(interp, "pop pages");
	}

	grow = pages * WASM_PAGE_SIZE;
	prev_size = active_pages(interp);

	if (interp->memory.p + grow <= interp->memory.end) {
		interp->memory.p += grow;
		pages = prev_size;
	} else {
		pages = -1;
	}

	return stack_push_i32(interp, pages);
}

static INLINE int interp_memory_size(struct wasm_interp *interp, u8 memidx)
{
	(void)memidx;

	if (unlikely(!has_memory_section(interp->module))) {
		return interp_error(interp, "no memory section");
	}

	if (!stack_push_i32(interp, active_pages(interp))) {
		return interp_error(interp, "push memory size");
	}

	return 1;
}

static INLINE int interp_i32_eq(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;

	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32))) {
		return interp_error(interp, "binop prep");
	}

	return stack_push_i32(interp, lhs.num.i32 == rhs.num.i32);
}

static INLINE int interp_i32_wrap_i64(struct wasm_interp *interp)
{
	int64_t n;
	if (unlikely(!stack_pop_i64(interp, &n)))
		return interp_error(interp, "pop");
	return stack_push_i32(interp, (int)n);
}

static INLINE int interp_i32_xor(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	return stack_push_i32(interp, lhs.num.i32 ^ rhs.num.i32);
}

static INLINE int interp_i32_ne(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	return stack_push_i32(interp, lhs.num.i32 != rhs.num.i32);
}

static int interp_i64_shl(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	c.num.i64 = lhs.num.i64 << shiftmask64(rhs.num.i64);
	return stack_pushval(interp, &c);
}

static int interp_i64_ne(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	make_i32_val(&c, lhs.num.i64 != rhs.num.i64);
	return stack_pushval(interp, &c);
}

static int interp_i64_eq(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	make_i32_val(&c, lhs.num.i64 == rhs.num.i64);
	return stack_pushval(interp, &c);
}

static int interp_i64_rem_s(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	c.num.i64 = lhs.num.i64 % rhs.num.i64;
	return stack_pushval(interp, &c);
}

static int interp_i64_rem_u(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	c.num.u64 = lhs.num.u64 % rhs.num.u64;
	return stack_pushval(interp, &c);
}

static int interp_i32_shr_u(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	c.num.u32 = lhs.num.u32 >> shiftmask32(rhs.num.u32);
	return stack_pushval(interp, &c);
}

static int interp_i32_shr_s(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	c.num.i32 = lhs.num.i32 >> shiftmask32(rhs.num.i32);
	return stack_pushval(interp, &c);
}

static int interp_i64_shr_u(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	c.num.u64 = lhs.num.u64 >> shiftmask64(rhs.num.u64);
	return stack_pushval(interp, &c);
}

static int interp_i64_shr_s(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i64)))
		return interp_error(interp, "binop prep");
	c.num.i64 = lhs.num.i64 >> shiftmask64(rhs.num.i64);
	return stack_pushval(interp, &c);
}


static int interp_i32_shl(struct wasm_interp *interp)
{
	struct val lhs, rhs, c;
	if (unlikely(!interp_prep_binop(interp, &lhs, &rhs, &c, val_i32)))
		return interp_error(interp, "binop prep");
	c.num.i32 = lhs.num.i32 << shiftmask32(rhs.num.i32);
	return stack_pushval(interp, &c);
}

#ifdef DEBUG
static void print_linestack(struct cursor *stack)
{
	struct val *val;
	int first = 1;

	val = (struct val*)stack->p;

	while (--val >= (struct val*)stack->start) {
		if (first) {
			first = 0;
		} else {
			printf(", ");
		}
		print_val(val);
	}

	printf("\n");
}

#endif

static int interp_extend(struct wasm_interp *interp, enum valtype to,
		enum valtype from, int sign)
{
	struct val *val;
	int64_t i64;
	int i32;
	(void)sign;

	if (unlikely(!(val = stack_topval(interp)))) {
		return interp_error(interp, "no value on stack");
	}

	if (val->type != from) {
		return interp_error(interp,
				"value on stack is of type %s, expected %s",
				valtype_name(val->type), valtype_name(from));
	}

	switch (from) {
	case val_i32:
		i64 = val->num.i32;
		val->num.i64 = i64;
		break;
	case val_i64:
		i32 = (int)val->num.i64;
		val->num.i32 = i32;
		break;
	default:
		return interp_error(interp, "unhandled extend from %s to %s",
				valtype_name(from), valtype_name(to));
	}

	val->type = to;
	return 1;
}

static INLINE int interp_drop(struct wasm_interp *interp)
{
	return cursor_drop(&interp->stack, sizeof(struct val));
}

static int interp_loop(struct wasm_interp *interp)
{
	struct blocktype blocktype;
	struct cursor *code;
	struct label *label;

	if (unlikely(!(code = interp_codeptr(interp)))) {
		return interp_error(interp, "empty callstack?");
	}

	if (unlikely(!parse_blocktype(code, &interp->errors, &blocktype))) {
		return interp_error(interp, "couldn't parse blocktype");
	}

	if (unlikely(!push_label_checkpoint(interp, &label, i_loop, i_end))) {
		return interp_error(interp, "block label checkpoint");
	}

	return 1;
}

static INLINE int table_set(struct wasm_interp *interp,
		struct table_inst *table, u32 ind, struct val *val)
{

	if (unlikely(ind >= table->num_refs)) {
		return interp_error(interp, "invalid index %d (max %d)",
				ind,
				interp->module_inst.num_tables);
	}

	if (unlikely(table->reftype != (enum reftype)val->type)) {
		return interp_error(interp, "can't store %s ref in %s table",
				valtype_name(val->type),
				valtype_name((enum valtype)table->reftype));
	}

	debug("setting table[%ld] ref %d to ",
	      (table - interp->module_inst.tables) / sizeof (struct table_inst),
	      ind);
#ifdef DEBUG
	print_refval(&val->ref, table->reftype);
	printf("\n");
#endif

	memcpy(&table->refs[ind], &val->ref, sizeof(struct refval));

	return 1;
}

static int interp_memory_copy(struct wasm_interp *interp)
{
	int dest, src, size;
	u8 *data_src, *data_dest;

	if (unlikely(!stack_pop_i32(interp, &size)))
		return interp_error(interp, "size");

	if (unlikely(!stack_pop_i32(interp, &src)))
		return interp_error(interp, "byte");

	if (unlikely(!stack_pop_i32(interp, &dest)))
		return interp_error(interp, "destination");

	if (!(data_dest = interp_mem_ptr(interp, dest, size)))
		return interp_error(interp, "memory copy dest out of bounds");

	if (!(data_src = interp_mem_ptr(interp, src, size)))
		return interp_error(interp, "memory copy src out of bounds");

	debug("memory.copy src:%d dst:%d size:%d\n",
			src, dest, size);

	memcpy(data_dest, data_src, size);

	return 1;
}

static int interp_memory_fill(struct wasm_interp *interp)
{
	int dest, byte, size;
	u8 *data;

	if (unlikely(!stack_pop_i32(interp, &size)))
		return interp_error(interp, "size");

	if (unlikely(!stack_pop_i32(interp, &byte)))
		return interp_error(interp, "byte");

	if (unlikely(!stack_pop_i32(interp, &dest)))
		return interp_error(interp, "destination");

	if (!(data = interp_mem_ptr(interp, dest, size)))
		return interp_error(interp, "memory fill out of bounds");

	debug("memory.fill dst:%d byte:%d size:%d\n",
			dest, byte, size);

	memset(data, byte, size);

	return 1;
}

static INLINE int interp_bulk_op(struct wasm_interp *interp, struct bulk_op *op)
{
	switch (op->tag) {
	case i_memory_fill: return interp_memory_fill(interp);
	case i_memory_copy: return interp_memory_copy(interp);
	case i_table_init:
	case i_elem_drop:
	case i_table_copy:
	case i_table_grow:
	case i_table_size:
	case i_table_fill:
		return interp_error(interp, "unhandled bulk op: %s",
				bulk_op_name(op));
	}

	return interp_error(interp, "unhandled unknown bulk op: %d", op->tag);
}

static int interp_table_set(struct wasm_interp *interp, u32 tableidx)
{
	struct table_inst *table;
	struct val val;
	int ind;

	if (unlikely(tableidx >= interp->module_inst.num_tables)) {
		return interp_error(interp, "tableidx oob %d (max %d)",
				tableidx,
				interp->module_inst.num_tables + 1);
	}

	table = &interp->module_inst.tables[tableidx];

	if (unlikely(!stack_pop_ref(interp, &val))) {
		return interp_error(interp, "pop ref");
	}

	if (unlikely(!stack_pop_i32(interp, &ind))) {
		return interp_error(interp, "pop elem index");
	}

	return table_set(interp, table, ind, &val);
}

static int interp_memory_init(struct wasm_interp *interp, u32 dataidx)
{
	struct wdata *data;
	int count, src, dst;
	u32 num_data;

	num_data = interp->module->data_section.num_datas;
	if (unlikely(dataidx >= num_data)) {
		return interp_error(interp, "invalid data index %d / %d",
				dataidx, num_data-1);
	}

	data = &interp->module->data_section.datas[dataidx];

	if(unlikely(!stack_pop_i32(interp, &count)))
		return interp_error(interp, "pop count");

	if(unlikely(!stack_pop_i32(interp, &src)))
		return interp_error(interp, "pop src");

	if(unlikely(!stack_pop_i32(interp, &dst)))
		return interp_error(interp, "pop dst");

	if (src + count > (int)data->bytes_len) {
		return interp_error(interp, "count %d > data len %d", count,
				data->bytes_len);
	}

	if (interp->memory.start + dst + count >= interp->memory.p) {
		return interp_error(interp, "memory write oob %d > %d",
				count, interp->memory.p - interp->memory.start);
	}

	debug("memory_init src:%d dst:%d count:%d\n",
			src, dst, count);

	memcpy(interp->memory.start + dst,
	       data->bytes + src,
	       count);

	return 1;

	/*
	for (; count; count--; dst++, src++) {
		if (unlikely(src + count > data)) {
			return interp_error(interp,
				"src %d (max %d)",
				src + count, num_data + 1);
		}

		if (unlikely(dst + count > active_pages(interp))) {
			return interp_error(interp, "dst oob",
					dst + count,
					table->num_refs + 1);
		}
	}
	*/
	return 1;
}

static int interp_table_init(struct wasm_interp *interp,
				  struct table_init *t)
{
	struct table_inst *table;
	struct elem_inst *elem_inst;
	int num_inits, dst, src;

	if (unlikely(t->tableidx >= interp->module_inst.num_tables)) {
		return interp_error(interp, "tableidx oob %d (max %d)",
				t->tableidx,
				interp->module_inst.num_tables + 1);
	}

	table = &interp->module_inst.tables[t->tableidx];

	// TODO: elem addr ?
	if (unlikely(t->elemidx >= interp->module->element_section.num_elements)) {
		return interp_error(interp, "elemidx oob %d (max %d)",
				t->elemidx,
				interp->module->element_section.num_elements + 1);
	}

	if (unlikely(!stack_pop_i32(interp, &num_inits))) {
		return interp_error(interp, "pop num_inits");
	}

	if (unlikely(!stack_pop_i32(interp, &src))) {
		return interp_error(interp, "pop src");
	}

	if (unlikely(!stack_pop_i32(interp, &dst))) {
		return interp_error(interp, "pop dst");
	}

	for (; num_inits; num_inits--, dst++, src++) {
		if (unlikely((u32)src + num_inits > interp->module_inst.num_elements)) {
			return interp_error(interp, "index oob elem.elem s+n %d (max %d)",
					src + num_inits,
					interp->module_inst.num_elements + 1);
		}

		if (unlikely((u32)dst + num_inits > table->num_refs)) {
			return interp_error(interp, "index oob tab.elem d+n %d (max %d)",
					dst + num_inits,
					table->num_refs + 1);
		}

		elem_inst = &interp->module_inst.elements[src];

		if (!table_set(interp, table, dst, &elem_inst->val)) {
			return interp_error(interp,
					"table set failed for table %d ind %d");
		}
	}

	return 1;
}

static int interp_select(struct wasm_interp *interp, struct select_instr *select)
{
	struct val top, bottom;
	int c;

	(void)select;

	if (unlikely(!stack_pop_i32(interp, &c)))
		return interp_error(interp, "pop select");

	if (unlikely(!stack_popval(interp, &top)))
		return interp_error(interp, "pop val top");

	if (unlikely(!stack_popval(interp, &bottom)))
		return interp_error(interp, "pop val bottom");

	if (unlikely(top.type != bottom.type))
		return interp_error(interp, "type mismatch, %s != %s",
				valtype_name(top.type),
				valtype_name(bottom.type));

	if (c != 0)
		return stack_pushval(interp, &bottom);
	else
		return stack_pushval(interp, &top);
}

enum interp_end {
	interp_end_err,
	interp_end_next,
	interp_end_done,
};

// tricky...
static int interp_end(struct wasm_interp *interp)
{
	struct callframe *frame;
	int loc_resolvers;

	if (unlikely(!(frame = top_callframe(&interp->callframes)))) {
		debug("no callframes, done.\n");
		// no more resolvers, we done.
		return interp_end_done;
	}

	if (unlikely(!count_local_resolvers(interp, &loc_resolvers))) {
		return interp_error(interp, "count local resolvers");
	}

	if (loc_resolvers == 0) {
		if (!drop_callframe(interp))
			return interp_error(interp, "drop callframe at end of fn");
		return interp_end_next;
	}

	return pop_label_checkpoint(interp);

}


static int interp_instr(struct wasm_interp *interp, struct instr *instr)
{
	interp->ops++;

	debug("%04X %-30s | ", instr->pos, show_instr(instr));

#if DEBUG
	print_linestack(&interp->stack);
#endif

	switch (instr->tag) {
	case i_unreachable: return interp_error(interp, "unreachable");
	case i_nop:         return 1;
	case i_select:
	case i_selects:
		return interp_select(interp, &instr->select);

	case i_local_get:   return interp_local_get(interp, instr->i32);
	case i_local_set:   return interp_local_set(interp, instr->i32);
	case i_local_tee:   return interp_local_tee(interp, instr->i32);
	case i_global_get:  return interp_global_get(interp, instr->i32);
	case i_global_set:  return interp_global_set(interp, instr->i32);

	case i_f32_const:   return interp_f32_const(interp, instr->f32);
	case i_f32_abs:     return interp_f32_abs(interp);
	case i_f32_div:     return interp_f32_div(interp);
	case i_f32_mul:     return interp_f32_mul(interp);
	case i_f32_neg:     return interp_f32_neg(interp);
	case i_f32_add:     return interp_f32_add(interp);
	case i_f32_sub:     return interp_f32_sub(interp);
	case i_f32_lt:      return interp_f32_lt(interp);
	case i_f32_le:      return interp_f32_le(interp);
	case i_f32_gt:      return interp_f32_gt(interp);
	case i_f32_ge:      return interp_f32_ge(interp);
	case i_f32_eq:      return interp_f32_eq(interp);
	case i_f32_ne:      return interp_f32_ne(interp);
	case i_f32_max:     return interp_f32_max(interp);
	case i_f32_min:     return interp_f32_max(interp);
	case i_f32_sqrt:    return interp_f32_sqrt(interp);

	case i_f32_convert_i32_s:   return interp_f32_convert_i32_s(interp);
	case i_i32_reinterpret_f32: return interp_i32_reinterpret_f32(interp);
	case i_f64_promote_f32:     return interp_f64_promote_f32(interp);
	case i_i32_trunc_f64_s:     return interp_i32_trunc_f64_s(interp);
	case i_f32_demote_f64:      return interp_f32_demote_f64(interp);
	case i_f64_convert_i32_s:   return interp_f64_convert_i32_s(interp);
	case i_f64_convert_i64_u:   return interp_f64_convert_i64_u(interp);
	case i_i64_reinterpret_f64: return interp_i64_reinterpret_f64(interp);
	case i_f64_reinterpret_i64: return interp_f64_reinterpret_i64(interp);
	case i_i32_trunc_f32_s:     return interp_i32_trunc_f32_s(interp);
	case i_f32_convert_i32_u:   return interp_f32_convert_i32_u(interp);
	case i_i32_trunc_f64_u:     return interp_i32_trunc_f64_u(interp);
	case i_f64_convert_i32_u:   return interp_f64_convert_i32_u(interp);
	case i_f32_reinterpret_i32: return interp_f32_reinterpret_i32(interp);

	case i_f64_abs:     return interp_f64_abs(interp);
	case i_f64_eq:      return interp_f64_eq(interp);
	case i_f64_ne:      return interp_f64_ne(interp);
	case i_f64_add:     return interp_f64_add(interp);
	case i_f64_neg:     return interp_f64_neg(interp);
	case i_f64_ceil:    return interp_f64_ceil(interp);
	case i_f64_floor:   return interp_f64_floor(interp);
	case i_f64_sqrt:    return interp_f64_sqrt(interp);
	case i_f64_const:   return interp_f64_const(interp, instr->f64);
	case i_f64_div:     return interp_f64_div(interp);
	case i_f64_ge:      return interp_f64_ge(interp);
	case i_f64_gt:      return interp_f64_gt(interp);
	case i_f64_le:      return interp_f64_le(interp);
	case i_f64_lt:      return interp_f64_lt(interp);
	case i_f64_mul:     return interp_f64_mul(interp);
	case i_f64_sub:     return interp_f64_sub(interp);

	case i_i32_clz:     return interp_i32_clz(interp);
	case i_i32_ctz:     return interp_i32_ctz(interp);
	case i_i32_popcnt:  return interp_i32_popcnt(interp);
	case i_i32_eqz:     return interp_i32_eqz(interp);
	case i_i32_add:     return interp_i32_add(interp);
	case i_i32_sub:     return interp_i32_sub(interp);
	case i_i32_const:   return interp_i32_const(interp, instr->i32);
	case i_i32_div_u:   return interp_i32_div_u(interp);
	case i_i32_div_s:   return interp_i32_div_s(interp);
	case i_i32_ge_u:    return interp_i32_ge_u(interp);
	case i_i32_rotl:    return interp_i32_rotl(interp);
	case i_i32_rotr:    return interp_i32_rotr(interp);
	case i_i32_ge_s:    return interp_i32_ge_s(interp);
	case i_i32_gt_u:    return interp_i32_gt_u(interp);
	case i_i32_gt_s:    return interp_i32_gt_s(interp);
	case i_i32_le_s:    return interp_i32_le_s(interp);
	case i_i32_le_u:    return interp_i32_le_u(interp);
	case i_i32_lt_s:    return interp_i32_lt_s(interp);
	case i_i32_lt_u:    return interp_i32_lt_u(interp);
	case i_i32_shl:     return interp_i32_shl(interp);
	case i_i32_shr_u:   return interp_i32_shr_u(interp);
	case i_i32_shr_s:   return interp_i32_shr_s(interp);
	case i_i32_or:      return interp_i32_or(interp);
	case i_i32_and:     return interp_i32_and(interp);
	case i_i32_mul:     return interp_i32_mul(interp);
	case i_i32_xor:     return interp_i32_xor(interp);
	case i_i32_ne:      return interp_i32_ne(interp);
	case i_i32_rem_u:   return interp_i32_rem_u(interp);
	case i_i32_rem_s:   return interp_i32_rem_s(interp);
	case i_i32_eq:      return interp_i32_eq(interp);
	case i_i32_wrap_i64:return interp_i32_wrap_i64(interp);

	case i_i64_clz:     return interp_i64_clz(interp);
	case i_i64_add:     return interp_i64_add(interp);
	case i_i64_and:     return interp_i64_and(interp);
	case i_i64_eqz:     return interp_i64_eqz(interp);
	case i_i64_gt_s:    return interp_i64_gt_s(interp);
	case i_i64_lt_u:    return interp_i64_lt_u(interp);
	case i_i64_lt_s:    return interp_i64_lt_s(interp);
	case i_i64_le_u:    return interp_i64_le_u(interp);
	case i_i64_le_s:    return interp_i64_le_s(interp);
	case i_i64_gt_u:    return interp_i64_gt_u(interp);
	case i_i64_ge_u:    return interp_i64_ge_u(interp);
	case i_i64_ge_s:    return interp_i64_ge_s(interp);
	case i_i64_div_u:   return interp_i64_div_u(interp);
	case i_i64_xor:     return interp_i64_xor(interp);
	case i_i64_mul:     return interp_i64_mul(interp);
	case i_i64_shl:     return interp_i64_shl(interp);
	case i_i64_ne:      return interp_i64_ne(interp);
	case i_i64_eq:      return interp_i64_eq(interp);
	case i_i64_rem_u:   return interp_i64_rem_u(interp);
	case i_i64_rem_s:   return interp_i64_rem_s(interp);
	case i_i64_shr_u:   return interp_i64_shr_u(interp);
	case i_i64_shr_s:   return interp_i64_shr_s(interp);
	case i_i64_or:      return interp_i64_or(interp);
	case i_i64_sub:     return interp_i64_sub(interp);

	case i_i64_const:        return interp_i64_const(interp, instr->i64);
	case i_i64_extend_i32_u: return interp_extend(interp, val_i64, val_i32, 0);
	case i_i64_extend_i32_s: return interp_extend(interp, val_i64, val_i32, 1);

	case i_i32_store:   return interp_store(interp, &instr->memarg, val_i32, 0);
	case i_i32_store8:  return interp_store(interp, &instr->memarg, val_i32, 8);
	case i_i32_store16: return interp_store(interp, &instr->memarg, val_i32, 16);
	case i_f32_store:   return interp_store(interp, &instr->memarg, val_f32, 0);
	case i_f64_store:   return interp_store(interp, &instr->memarg, val_f64, 0);
	case i_i64_store:   return interp_store(interp, &instr->memarg, val_i64, 0);
	case i_i64_store8:  return interp_store(interp, &instr->memarg, val_i64, 8);
	case i_i64_store16: return interp_store(interp, &instr->memarg, val_i64, 16);
	case i_i64_store32: return interp_store(interp, &instr->memarg, val_i64, 32);

	case i_i32_load:     return interp_load(interp, &instr->memarg, val_i32, 0, -1);
	case i_i32_load8_s:  return interp_load(interp, &instr->memarg, val_i32, 8, 1);
	case i_i32_load8_u:  return interp_load(interp, &instr->memarg, val_i32, 8, 0);
	case i_i32_load16_s: return interp_load(interp, &instr->memarg, val_i32, 16, 1);
	case i_i32_load16_u: return interp_load(interp, &instr->memarg, val_i32, 16, 0);
	case i_f32_load:     return interp_load(interp, &instr->memarg, val_f32, 0, -1);
	case i_f64_load:     return interp_load(interp, &instr->memarg, val_f64, 0, -1);
	case i_i64_load:     return interp_load(interp, &instr->memarg, val_i64, 0, -1);
	case i_i64_load8_s:  return interp_load(interp, &instr->memarg, val_i64, 8, 1);
	case i_i64_load8_u:  return interp_load(interp, &instr->memarg, val_i64, 8, 0);
	case i_i64_load16_s: return interp_load(interp, &instr->memarg, val_i64, 16, 1);
	case i_i64_load16_u: return interp_load(interp, &instr->memarg, val_i64, 16, 0);
	case i_i64_load32_s: return interp_load(interp, &instr->memarg, val_i64, 32, 1);
	case i_i64_load32_u: return interp_load(interp, &instr->memarg, val_i64, 32, 0);

	case i_drop:          return interp_drop(interp);
	case i_loop:          return interp_loop(interp);
	case i_if:            return interp_if(interp);
	case i_else:          return interp_else(interp);
	case i_end:           return interp_end(interp);
	case i_call:          return interp_call(interp, instr->i32);
	case i_call_indirect: return interp_call_indirect(interp, &instr->call_indirect);
	case i_block:         return interp_block(interp);
	case i_br:            return interp_br(interp, instr->i32);
	case i_br_table:      return interp_br_table(interp, &instr->br_table);
	case i_br_if:         return interp_br_if(interp, instr->i32);
	case i_memory_size:   return interp_memory_size(interp, instr->memidx);
	case i_memory_grow:   return interp_memory_grow(interp, instr->memidx);
	case i_bulk_op:       return interp_bulk_op(interp, &instr->bulk_op);
	case i_table_set:     return interp_table_set(interp, instr->i32);
	case i_return:        return interp_return(interp);
	default:
		    interp_error(interp, "unhandled instruction %s 0x%x",
				 instr_name(instr->tag), instr->tag);
		    return 0;
	}

	return 0;
}

static int is_control_instr(u8 tag)
{
	switch (tag) {
		case i_if:
		case i_block:
		case i_loop:
			return 1;
	}
	return 0;
}


static INLINE int interp_parse_instr(struct wasm_interp *interp,
		struct cursor *code, struct expr_parser *parser,
		struct instr *instr)
{
	u8 tag;

	if (unlikely(!pull_byte(code, &tag))) {
		return interp_error(interp, "no more instrs to pull");
	}


	instr->tag = tag;
	instr->pos = (int)(code->p - 1 - code->start);

	if (is_control_instr(tag)) {
		return 1;
	}

	parser->code = code;
	if (!parse_instr(parser, instr->tag, instr)) {
		return interp_error(interp, "parse non-control instr %s", instr_name(tag));
	}

	return 1;
}

static int interp_elem_drop(struct wasm_interp *interp, int elemidx)
{
	(void)interp;
	(void)elemidx;
	// we don't really need to do anything here...
	return 1;
}

static int interp_code(struct wasm_interp *interp)
{
	struct instr instr;
	struct expr_parser parser;
	struct callframe *frame;
	int ret;

	parser.interp = interp;
	parser.errs = &interp->errors;

	for (;;) {
		if (unlikely(!(frame = top_callframe(&interp->callframes)))) {
			return 1;
		}

		if (unlikely(!interp_parse_instr(interp, &frame->code, &parser,
						&instr))) {
			return interp_error(interp, "parse instr");
		}

		//cursor_print_around(&frame->code, 10);

		if (unlikely(!(ret = interp_instr(interp, &instr)))) {
			return interp_error(interp, "interp instr %s",
					show_instr(&instr));
		}

		if (instr.tag == i_end) {
			//cursor_print_around(&frame->code, 10);
			switch (ret) {
				case interp_end_err: return 0;
				case interp_end_done: return 1;
				case interp_end_next: break;
			}
		}

		if (ret == BUILTIN_SUSPEND)
			return BUILTIN_SUSPEND;
	}

	return 1;
}

static int find_function(struct module *module, const char *name)
{
	struct wexport *export;
	u32 i;

	for (i = 0; i < module->export_section.num_exports; i++) {
		export = &module->export_section.exports[i];
		if (!strcmp(name, export->name)) {
			return export->index;
		}
	}

	return -1;
}

static int find_start_function(struct module *module)
{
	int res;

	if (was_section_parsed(module, section_start)) {
		debug("getting start function from start section\n");
		return module->start_section.start_fn;
	}

	if ((res = find_function(module, "_start")) != -1) {
		return res;
	}

	return find_function(module, "start");
}

void wasm_parser_init(struct wasm_parser *p, u8 *wasm, size_t wasm_len, size_t arena_size, struct builtin *builtins, int num_builtins)
{
	u8 *mem;

	mem = calloc(1, arena_size);
	assert(mem);

	make_cursor(wasm, wasm + wasm_len, &p->cur);
	make_cursor(mem, mem + arena_size, &p->mem);

	p->errs.enabled = 1;
    p->num_builtins = 0;
    
    p->builtins = builtins;
    p->num_builtins = num_builtins;

	cursor_slice(&p->mem, &p->errs.cur, 0xFFFF);
}

static int calculate_tables_size(struct module *module)
{
	u32 i, num_tables, size;
	struct table *tables;

	if (!was_section_parsed(module, section_table))
		return 0;

	tables = module->table_section.tables;
	num_tables = module->table_section.num_tables;
	size = num_tables * sizeof(struct table_inst);

	for (i = 0; i < num_tables; i++) {
		size += sizeof(struct refval) * tables[i].limits.min;
	}

	return size;
}

static int alloc_tables(struct wasm_interp *interp)
{
	struct table *t;
	struct table_inst *inst;
	u32 i, size;

	if (!was_section_parsed(interp->module, section_table))
		return 1;

	interp->module_inst.num_tables =
		interp->module->table_section.num_tables;

	if (!(interp->module_inst.tables =
		cursor_alloc(&interp->mem, interp->module_inst.num_tables *
			     sizeof(struct table_inst)))) {
		return interp_error(interp, "couldn't alloc table instances");
	}

	for (i = 0; i < interp->module_inst.num_tables; i++) {
		t = &interp->module->table_section.tables[i];
		inst = &interp->module_inst.tables[i];
		inst->reftype = t->reftype;
		inst->num_refs = t->limits.min;
		size = sizeof(struct refval) * t->limits.min;

		if (!(inst->refs = cursor_alloc(&interp->mem, size))) {
			return interp_error(interp,
				"couldn't alloc table inst %d/%d",
				i+1, interp->module->table_section.num_tables);
		}
	}

	return 1;
}

static int init_element(struct wasm_interp *interp, struct expr *init,
		struct elem_inst *elem_inst)
{
	if (!eval_const_val(init, &interp->errors, &interp->stack, &elem_inst->val)) {
		return interp_error(interp, "failed to eval element init expr");
	}
	return 1;
}

static int init_table(struct wasm_interp *interp, struct elem *elem,
		int elemidx, int num_elems)
{
	struct table_init t;

	if (elem->tableidx != 0) {
		return interp_error(interp,
			"tableidx should be 0 for elem %d", elemidx);
	}

	if (!eval_const_expr(&elem->offset, &interp->errors, &interp->stack)) {
		return interp_error(interp, "failed to eval elem offset expr");
	}

	if (!stack_push_i32(interp, 0)) {
		return interp_error(interp, "push 0 when init element");
	}

	if (!stack_push_i32(interp, num_elems)) {
		return interp_error(interp, "push num_elems in init element");
	}

	t.tableidx = elem->tableidx;
	t.elemidx  = elemidx;

	if (!interp_table_init(interp, &t)) {
		return interp_error(interp, "table init");
	}

	if (!interp_elem_drop(interp, elemidx)) {
		return interp_error(interp, "drop elem");
	}

	return 1;
}

static int init_global(struct wasm_interp *interp, struct global *global,
		struct global_inst *global_inst)
{
	if (!eval_const_val(&global->init, &interp->errors, &interp->stack,
			    &global_inst->val)) {
		return interp_error(interp, "eval const expr");
	}

	debug("init global to %s %d\n", valtype_name(global_inst->val.type),
			global_inst->val.num.i32);

	if (cursor_top(&interp->stack, sizeof(struct val))) {
		return interp_error(interp, "stack not empty");
	}

	return 1;
}

static int init_globals(struct wasm_interp *interp)
{
	struct global *globals, *global;
	struct global_inst *global_insts, *global_inst;
	u32 i;

	if (!was_section_parsed(interp->module, section_global)) {
		// nothing to init
		return 1;
	}

	globals = interp->module->global_section.globals;
	global_insts = interp->module_inst.globals;

	for (i = 0; i < interp->module->global_section.num_globals; i++) {
		global = &globals[i];
		global_inst = &global_insts[i];

		if (!init_global(interp, global, global_inst)) {
			return interp_error(interp, "global init");
		}
	}

	return 1;
}

static int count_element_insts(struct module *module)
{
	struct elem *elem;
	u32 i, size = 0;

	if (!was_section_parsed(module, section_element))
		return 0;

	for (i = 0; i < module->element_section.num_elements; i++) {
		elem = &module->element_section.elements[i];
		size += elem->num_inits;
	}

	return size;
}

static int init_memory(struct wasm_interp *interp, struct wdata *data, int dataidx)
{
	if (!eval_const_expr(&data->active.offset_expr, &interp->errors,
				&interp->stack)) {
		return interp_error(interp, "failed to eval data offset expr");
	}

	if (!stack_push_i32(interp, 0)) {
		return interp_error(interp, "push 0 when init element");
	}

	if (!stack_push_i32(interp, data->bytes_len)) {
		return interp_error(interp, "push num_elems in init element");
	}

	if (!interp_memory_init(interp, dataidx)) {
		return interp_error(interp, "table init");
	}

	/*
	if (!interp_data_drop(interp, elemidx)) {
		return interp_error(interp, "drop elem");
	}
	*/

	return 1;
}

static int init_memories(struct wasm_interp *interp)
{
	struct wdata *data;
	u32 i;

	debug("init memories\n");

	if (!was_section_parsed(interp->module, section_data))
		return 1;

	if (!was_section_parsed(interp->module, section_memory))
		return 1;

	for (i = 0; i < interp->module->data_section.num_datas; i++) {
		data = &interp->module->data_section.datas[i];

		if (data->mode != datamode_active)
			continue;

		if (!init_memory(interp, data, i)) {
			return interp_error(interp, "init memory %d failed", i);
		}
	}

	return 1;
}

static int init_tables(struct wasm_interp *interp)
{
	struct elem *elem;
	u32 i;

	if (!was_section_parsed(interp->module, section_table))
		return 1;

	for (i = 0; i < interp->module->element_section.num_elements; i++) {
		elem = &interp->module->element_section.elements[i];

		if (elem->mode != elem_mode_active)
			continue;

		if (!init_table(interp, elem, i, elem->num_inits)) {
			return interp_error(interp, "init table failed");
		}
	}

	return 1;
}

static int init_elements(struct wasm_interp *interp)
{
	struct elem *elems, *elem;
	struct elem_inst *inst;
	struct expr *init;
	u32 count = 0;
	u32 i, j;

	debug("init elements\n");

	if (!was_section_parsed(interp->module, section_element))
		return 1;

	elems = interp->module->element_section.elements;

	for (i = 0; i < interp->module->element_section.num_elements; i++) {
		elem = &elems[i];

		if (elem->mode != elem_mode_active)
			continue;

		for (j = 0; j < elem->num_inits; j++, count++) {
			init = &elem->inits[j];

			assert(count < interp->module_inst.num_elements);
			inst = &interp->module_inst.elements[count];
			inst->elem = i;
			inst->init = j;

			if (!init_element(interp, init, inst)) {
				return interp_error(interp, "init element %d", j);
			}
		}

	}

	return 1;
}

// https://webassembly.github.io/spec/core/exec/modules.html#instantiation
static int instantiate_module(struct wasm_interp *interp)
{
	int func;
	//TODO:Assert module is valid with external types classifying its imports

	// TODO: If the number # of imports is not equal to the number of provided external values then fail

	/*
	if (!push_aux_callframe(interp)) {
		return interp_error(interp,
			"failed to pushed aux callframe?? "
			"ok if this happens seriously wtf why am I even"
			" writing this error message..)";
	}
	*/

	func = interp->module_inst.start_fn != -1
	     ? interp->module_inst.start_fn
	     : find_start_function(interp->module);

	/*
	memset(interp->module_inst.globals, 0,
			interp->module_inst.num_globals *
			sizeof(*interp->module_inst.globals));

	memset(interp->module_inst.globals_init, 0,
			interp->module_inst.num_globals);
			*/

	if (func == -1) {
		return interp_error(interp, "no start function found");
	} else {
		interp->module_inst.start_fn = func;
		debug("found start function %s (%d)\n",
				get_function_name(interp->module, func), func);
	}

	if (!init_memories(interp)) {
		return interp_error(interp, "memory init");
	}

	if (!init_elements(interp)) {
		return interp_error(interp, "elements init");
	}

	if (!init_tables(interp)) {
		return interp_error(interp, "table init");
	}

	if (!init_globals(interp)) {
		return interp_error(interp, "globals init");
	}

	return 1;
}

static int reset_memory(struct wasm_interp *interp)
{
	int pages, num_mems;

	num_mems = was_section_parsed(interp->module, section_memory)?
		interp->module->memory_section.num_mems : 0;

	reset_cursor(&interp->memory);

	if (num_mems == 1) {
		pages = interp->module->memory_section.mems[0].min;

		if (pages == 0)
			return 1;

		if (!cursor_malloc(&interp->memory, pages * WASM_PAGE_SIZE)) {
			return interp_error(interp,
					"could not alloc %d memory pages",
					pages);
		}

		assert(interp->memory.p > interp->memory.start);
		// I technically need this...
		//memset(interp->memory.start, 0, pages * WASM_PAGE_SIZE);
	}

	return 1;
}

void setup_wasi(struct wasm_interp *interp, int argc,
		const char **argv, char **env)
{
	char **s = env;

	interp->wasi.argc = argc;
	interp->wasi.argv = argv;

	interp->wasi.environ = (const char**)env;
	interp->wasi.environc = 0;
	if (env)
		for (; *s; s++, interp->wasi.environc++);
}

int wasm_interp_init(struct wasm_interp *interp, struct module *module)
{
	unsigned char *mem, *heap, *start;

	unsigned int ok, fns, errors_size, stack_size, locals_size,
	    callframes_size, resolver_size, labels_size, num_labels_size,
	    labels_capacity, memsize, memory_pages_size,
	    resolver_offsets_size, num_mems, globals_size, num_globals,
	    tables_size, elems_size, num_elements;

	memset(interp, 0, sizeof(*interp));

	setup_wasi(interp, 0, NULL, NULL);

	interp->quitting = 0;
	interp->module = module;

	interp->module_inst.start_fn = -1;

	interp->prev_resolvers = 0;

	//stack = calloc(1, STACK_SPACE);
	fns = module->num_funcs;
	labels_capacity  = fns * MAX_LABELS;
	debug("%d fns, labels capacity %d\n", fns, labels_capacity);

	num_mems = was_section_parsed(module, section_memory)?
		module->memory_section.num_mems : 0;

	num_globals = was_section_parsed(module, section_global)?
		module->global_section.num_globals : 0;

	// TODO: make memory limits configurable
	errors_size      = 0xFFF;
	stack_size       = sizeof(struct val) * 0xFF;
 	labels_size      = labels_capacity * sizeof(struct label);
 	num_labels_size  = fns * sizeof(u16);
	resolver_offsets_size = sizeof(int) * 2048;
	callframes_size  = sizeof(struct callframe) * 2048;
	resolver_size    = sizeof(struct resolver) * MAX_LABELS * 32;
	globals_size     = sizeof(struct global_inst) * num_globals;

	num_elements     = count_element_insts(module);
	elems_size       = num_elements * sizeof(struct elem_inst);
	locals_size      = 1024 * 1024 * 5; // 5MB stack?
	tables_size      = calculate_tables_size(module);

	if (num_mems > 1) {
		printf("more than one memory instance is not supported\n");
		return 0;
	}

	// keep total memory size small for now, iOS doesn't like like mallocs
	memory_pages_size = 8 * WASM_PAGE_SIZE;

	memsize =
		stack_size +
		errors_size +
		resolver_offsets_size +
		resolver_size +
		callframes_size +
		globals_size +
		num_globals +
		labels_size +
		num_labels_size +
		locals_size +
		tables_size +
		elems_size
		;

	mem = calloc(1, memsize);
	heap = malloc(memory_pages_size);

	make_cursor(mem, mem + memsize, &interp->mem);
	make_cursor(heap, heap + memory_pages_size, &interp->memory);

	// enable error reporting by default
	interp->errors.enabled = 1;

	start = interp->mem.p;

	ok = cursor_slice(&interp->mem, &interp->stack, stack_size);
	assert(interp->mem.p - start == stack_size);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->errors.cur, errors_size);
	assert(interp->mem.p - start == errors_size);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->resolver_offsets, resolver_offsets_size);
	assert(interp->mem.p - start == resolver_offsets_size);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->resolver_stack, resolver_size);
	assert(interp->mem.p - start == resolver_size);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->callframes, callframes_size);
	assert(interp->mem.p - start == callframes_size);

	interp->module_inst.num_globals = num_globals;

	start = interp->mem.p;
	ok = ok && (interp->module_inst.globals = cursor_alloc(&interp->mem, globals_size));
	assert(interp->mem.p - start == globals_size);

	start = interp->mem.p;
	ok = ok && (interp->module_inst.globals_init = cursor_alloc(&interp->mem, num_globals));
	assert(interp->mem.p - start == num_globals);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->labels, labels_size);
	assert(interp->mem.p - start == labels_size);

	start = interp->mem.p;
	ok = ok && alloc_tables(interp);
	assert(interp->mem.p - start == tables_size);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->num_labels, num_labels_size);
	assert(interp->mem.p - start == num_labels_size);

	start = interp->mem.p;
	ok = ok && cursor_slice(&interp->mem, &interp->locals, locals_size);
	assert(interp->mem.p - start == locals_size);

	interp->module_inst.num_elements = num_elements;

	start = interp->mem.p;
	ok = ok && (interp->module_inst.elements =
			cursor_alloc(&interp->mem, elems_size));
	assert(interp->mem.p - start == elems_size);

	/* init memory pages */
	assert((interp->mem.end - interp->mem.start) == memsize);

	if (!ok) {
		return interp_error(interp, "not enough memory");
	}

	return 1;
}

void wasm_parser_free(struct wasm_parser *parser)
{
    if (parser->mem.start) {
        free(parser->mem.start);
        parser->mem.start = 0;
    }
}

void wasm_interp_free(struct wasm_interp *interp)
{
    if (interp->mem.start) {
        free(interp->mem.start);
        interp->mem.start = 0;
    }
    if (interp->memory.start) {
        free(interp->memory.start);
        interp->memory.start = 0;
    }
}

int interp_wasm_module_resume(struct wasm_interp *interp, int *retval)
{
    int res = interp_code(interp);

    if (res == 1) {
        stack_pop_i32(interp, retval);
        debug("interp success!!\n");
    } else if (interp->quitting) {
        stack_pop_i32(interp, retval);
        debug("process exited\n");
    } else if (res == BUILTIN_SUSPEND) {
        return BUILTIN_SUSPEND;
    } else {
        *retval = 8;
        return interp_error(interp, "interp_code");
    }

    return 1;
}

int interp_wasm_module(struct wasm_interp *interp, int *retval)
{
	interp->ops = 0;
	*retval = 0;

	if (interp->module->code_section.num_funcs == 0) {
		interp_error(interp, "empty module");
		return 0;
	}

	// reset cursors
	reset_cursor(&interp->stack);
	reset_cursor(&interp->resolver_stack);
	reset_cursor(&interp->resolver_offsets);
	reset_cursor(&interp->errors.cur);
	reset_cursor(&interp->callframes);

	// don't reset labels for perf!

	if (!reset_memory(interp))
		return interp_error(interp, "reset memory");

	if (!instantiate_module(interp))
		return interp_error(interp, "instantiate module");

	//interp->mem.p = interp->mem.start;

	if (!call_function(interp, interp->module_inst.start_fn)) {
		return interp_error(interp, "call start function");
	}

    return interp_wasm_module_resume(interp, retval);
}

int run_wasm(unsigned char *wasm, unsigned long len,
		int argc, const char **argv, char **env,
		int *retval)
{
	struct wasm_parser p;
	struct wasm_interp interp;

	wasm_parser_init(&p, wasm, len, len * 16, 0, 0);

	if (!parse_wasm(&p)) {
		wasm_parser_free(&p);
		return 0;
	}

	if (!wasm_interp_init(&interp, &p.module)) {
		print_error_backtrace(&interp.errors);
		return 0;
	}

	setup_wasi(&interp, argc, argv, env);

	if (!interp_wasm_module(&interp, retval)) {
		print_callstack(&interp);
		print_error_backtrace(&interp.errors);
	}

	print_stack(&interp.stack);
	wasm_interp_free(&interp);
	wasm_parser_free(&p);

	return 1;
}