diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000..6f9e95e856
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "wasmparser.rs"]
+	path = wasmparser.rs
+	url = git@github.com:Vurich/wasmparser.rs
diff --git a/Cargo.toml b/Cargo.toml
index b7801bd8d3..5e8c250527 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,13 +9,21 @@ keywords = ["webassembly", "wasm", "compile", "compiler", "jit"]
 publish = false
 
 [dependencies]
+smallvec = "0.6"
 dynasm = "0.2.3"
 dynasmrt = "0.2.3"
-wasmparser = "0.21.6"
+wasmparser = { path = "./wasmparser.rs" }
+memoffset = "0.2"
+itertools = "0.8"
 capstone = "0.5.0"
 failure = "0.1.3"
 failure_derive = "0.1.3"
+cranelift-codegen = "0.28"
+multi_mut = "0.1"
+either = "1.5"
 wabt = "0.7"
+lazy_static = "1.2"
+quickcheck = "0.7"
 
 [badges]
 maintenance = { status = "experimental" }
diff --git a/examples/test.rs b/examples/test.rs
index 163dda0142..3fcbf7c573 100644
--- a/examples/test.rs
+++ b/examples/test.rs
@@ -22,7 +22,7 @@ fn read_to_end<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
 fn maybe_main() -> Result<(), String> {
     let data = read_to_end("test.wasm").map_err(|e| e.to_string())?;
     let translated = translate(&data).map_err(|e| e.to_string())?;
-    let result: u32 = unsafe { translated.execute_func(0, (5u32, 3u32)) };
+    let result: u32 = translated.execute_func(0, (5u32, 3u32)).unwrap();
     println!("f(5, 3) = {}", result);
 
     Ok(())
diff --git a/src/backend.rs b/src/backend.rs
index 0c996f90c3..90d15cac19 100644
--- a/src/backend.rs
+++ b/src/backend.rs
@@ -1,15 +1,129 @@
 #![allow(dead_code)] // for now
 
+use microwasm::{BrTarget, SignlessType, Type, F32, F64, I32, I64};
+
+use self::registers::*;
 use dynasmrt::x64::Assembler;
 use dynasmrt::{AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi, ExecutableBuffer};
 use error::Error;
-use std::iter;
+use microwasm::Value;
+use module::{ModuleContext, RuntimeFunc};
+use std::{
+    iter::{self, FromIterator},
+    mem,
+    ops::RangeInclusive,
+};
 
 /// Size of a pointer on the target in bytes.
 const WORD_SIZE: u32 = 8;
 
-type GPR = u8;
+type RegId = u8;
 
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum GPR {
+    Rq(RegId),
+    Rx(RegId),
+}
+
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum GPRType {
+    Rq,
+    Rx,
+}
+
+impl From<SignlessType> for GPRType {
+    fn from(other: SignlessType) -> GPRType {
+        match other {
+            I32 | I64 => GPRType::Rq,
+            F32 | F64 => GPRType::Rx,
+        }
+    }
+}
+
+impl From<SignlessType> for Option<GPRType> {
+    fn from(other: SignlessType) -> Self {
+        Some(other.into())
+    }
+}
+
+impl GPR {
+    fn type_(&self) -> GPRType {
+        match self {
+            GPR::Rq(_) => GPRType::Rq,
+            GPR::Rx(_) => GPRType::Rx,
+        }
+    }
+
+    fn rq(self) -> Option<RegId> {
+        match self {
+            GPR::Rq(r) => Some(r),
+            GPR::Rx(_) => None,
+        }
+    }
+
+    fn rx(self) -> Option<RegId> {
+        match self {
+            GPR::Rx(r) => Some(r),
+            GPR::Rq(_) => None,
+        }
+    }
+}
+
+pub fn arg_locs(types: impl IntoIterator<Item = SignlessType>) -> Vec<CCLoc> {
+    let types = types.into_iter();
+    let mut out = Vec::with_capacity(types.size_hint().0);
+    // TODO: VmCtx is in the first register
+    let mut int_gpr_iter = INTEGER_ARGS_IN_GPRS.into_iter();
+    let mut float_gpr_iter = FLOAT_ARGS_IN_GPRS.into_iter();
+    let mut stack_idx = 0;
+
+    for ty in types {
+        match ty {
+            I32 | I64 => out.push(int_gpr_iter.next().map(|&r| CCLoc::Reg(r)).unwrap_or_else(
+                || {
+                    let out = CCLoc::Stack(stack_idx);
+                    stack_idx += 1;
+                    out
+                },
+            )),
+            F32 | F64 => out.push(
+                float_gpr_iter
+                    .next()
+                    .map(|&r| CCLoc::Reg(r))
+                    .expect("Float args on stack not yet supported"),
+            ),
+        }
+    }
+
+    out
+}
+
+pub fn ret_locs(types: impl IntoIterator<Item = SignlessType>) -> Vec<CCLoc> {
+    let types = types.into_iter();
+    let mut out = Vec::with_capacity(types.size_hint().0);
+    // TODO: VmCtx is in the first register
+    let mut int_gpr_iter = INTEGER_RETURN_GPRS.into_iter();
+    let mut float_gpr_iter = FLOAT_RETURN_GPRS.into_iter();
+
+    for ty in types {
+        match ty {
+            I32 | I64 => out.push(CCLoc::Reg(
+                *int_gpr_iter
+                    .next()
+                    .expect("We don't support stack returns yet"),
+            )),
+            F32 | F64 => out.push(CCLoc::Reg(
+                *float_gpr_iter
+                    .next()
+                    .expect("We don't support stack returns yet"),
+            )),
+        }
+    }
+
+    out
+}
+
+#[derive(Debug, Copy, Clone)]
 struct GPRs {
     bits: u16,
 }
@@ -20,148 +134,372 @@ impl GPRs {
     }
 }
 
-const RAX: u8 = 0;
-const RCX: u8 = 1;
-const RDX: u8 = 2;
-const RBX: u8 = 3;
-const RSP: u8 = 4;
-const RBP: u8 = 5;
-const RSI: u8 = 6;
-const RDI: u8 = 7;
-const R8: u8 = 8;
-const R9: u8 = 9;
-const R10: u8 = 10;
-const R11: u8 = 11;
-const R12: u8 = 12;
-const R13: u8 = 13;
-const R14: u8 = 14;
-const R15: u8 = 15;
+pub mod registers {
+    use super::{RegId, GPR};
 
-impl GPRs {
-    fn take(&mut self) -> GPR {
-        let lz = self.bits.trailing_zeros();
-        assert!(lz < 32, "ran out of free GPRs");
-        self.bits &= !(1 << lz);
-        lz as GPR
+    pub mod rq {
+        use super::RegId;
+
+        pub const RAX: RegId = 0;
+        pub const RCX: RegId = 1;
+        pub const RDX: RegId = 2;
+        pub const RBX: RegId = 3;
+        pub const RSP: RegId = 4;
+        pub const RBP: RegId = 5;
+        pub const RSI: RegId = 6;
+        pub const RDI: RegId = 7;
+        pub const R8: RegId = 8;
+        pub const R9: RegId = 9;
+        pub const R10: RegId = 10;
+        pub const R11: RegId = 11;
+        pub const R12: RegId = 12;
+        pub const R13: RegId = 13;
+        pub const R14: RegId = 14;
+        pub const R15: RegId = 15;
     }
 
-    fn release(&mut self, gpr: GPR) {
-        assert!(!self.is_free(gpr), "released register was already free",);
+    pub const RAX: GPR = GPR::Rq(self::rq::RAX);
+    pub const RCX: GPR = GPR::Rq(self::rq::RCX);
+    pub const RDX: GPR = GPR::Rq(self::rq::RDX);
+    pub const RBX: GPR = GPR::Rq(self::rq::RBX);
+    pub const RSP: GPR = GPR::Rq(self::rq::RSP);
+    pub const RBP: GPR = GPR::Rq(self::rq::RBP);
+    pub const RSI: GPR = GPR::Rq(self::rq::RSI);
+    pub const RDI: GPR = GPR::Rq(self::rq::RDI);
+    pub const R8: GPR = GPR::Rq(self::rq::R8);
+    pub const R9: GPR = GPR::Rq(self::rq::R9);
+    pub const R10: GPR = GPR::Rq(self::rq::R10);
+    pub const R11: GPR = GPR::Rq(self::rq::R11);
+    pub const R12: GPR = GPR::Rq(self::rq::R12);
+    pub const R13: GPR = GPR::Rq(self::rq::R13);
+    pub const R14: GPR = GPR::Rq(self::rq::R14);
+    pub const R15: GPR = GPR::Rq(self::rq::R15);
+
+    pub const XMM0: GPR = GPR::Rx(0);
+    pub const XMM1: GPR = GPR::Rx(1);
+    pub const XMM2: GPR = GPR::Rx(2);
+    pub const XMM3: GPR = GPR::Rx(3);
+    pub const XMM4: GPR = GPR::Rx(4);
+    pub const XMM5: GPR = GPR::Rx(5);
+    pub const XMM6: GPR = GPR::Rx(6);
+    pub const XMM7: GPR = GPR::Rx(7);
+    pub const XMM8: GPR = GPR::Rx(8);
+    pub const XMM9: GPR = GPR::Rx(9);
+    pub const XMM10: GPR = GPR::Rx(10);
+    pub const XMM11: GPR = GPR::Rx(11);
+    pub const XMM12: GPR = GPR::Rx(12);
+    pub const XMM13: GPR = GPR::Rx(13);
+    pub const XMM14: GPR = GPR::Rx(14);
+    pub const XMM15: GPR = GPR::Rx(15);
+
+    pub const NUM_GPRS: u8 = 16;
+}
+
+extern "sysv64" fn println(len: u64, args: *const u8) {
+    println!("{}", unsafe {
+        std::str::from_utf8_unchecked(std::slice::from_raw_parts(args, len as usize))
+    });
+}
+
+#[allow(unused_macros)]
+macro_rules! asm_println {
+    ($asm:expr) => {asm_println!($asm,)};
+    ($asm:expr, $($args:tt)*) => {{
+        use std::mem;
+
+        let mut args = format!($($args)*).into_bytes();
+
+        let len = args.len();
+        let ptr = args.as_mut_ptr();
+        mem::forget(args);
+
+        dynasm!($asm
+            ; push rdi
+            ; push rsi
+            ; push rdx
+            ; push rcx
+            ; push r8
+            ; push r9
+            ; push r10
+            ; push r11
+
+            ; mov rax, QWORD println as *const u8 as i64
+            ; mov rdi, QWORD len as i64
+            ; mov rsi, QWORD ptr as i64
+
+            ; test rsp, 0b1111
+            ; jnz >with_adjusted_stack_ptr
+
+            ; call rax
+            ; jmp >pop_rest
+
+            ; with_adjusted_stack_ptr:
+            ; push 1
+            ; call rax
+            ; pop r11
+
+            ; pop_rest:
+            ; pop r11
+            ; pop r10
+            ; pop r9
+            ; pop r8
+            ; pop rcx
+            ; pop rdx
+            ; pop rsi
+            ; pop rdi
+        );
+    }}
+}
+
+impl GPRs {
+    fn take(&mut self) -> RegId {
+        let lz = self.bits.trailing_zeros();
+        debug_assert!(lz < 16, "ran out of free GPRs");
+        let gpr = lz as RegId;
+        self.mark_used(gpr);
+        gpr
+    }
+
+    fn mark_used(&mut self, gpr: RegId) {
+        self.bits &= !(1 << gpr as u16);
+    }
+
+    fn release(&mut self, gpr: RegId) {
+        debug_assert!(
+            !self.is_free(gpr),
+            "released register {} was already free",
+            gpr
+        );
         self.bits |= 1 << gpr;
     }
 
-    fn is_free(&self, gpr: GPR) -> bool {
+    fn free_count(&self) -> u32 {
+        self.bits.count_ones()
+    }
+
+    fn is_free(&self, gpr: RegId) -> bool {
         (self.bits & (1 << gpr)) != 0
     }
 }
 
+#[derive(Debug, Copy, Clone)]
 pub struct Registers {
-    scratch_gprs: GPRs,
+    /// Registers at 64 bits and below (al/ah/ax/eax/rax, for example)
+    scratch_64: (GPRs, [u8; NUM_GPRS as usize]),
+    /// Registers at 128 bits (xmm0, for example)
+    scratch_128: (GPRs, [u8; NUM_GPRS as usize]),
+}
+
+impl Default for Registers {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl Registers {
     pub fn new() -> Self {
         let mut result = Self {
-            scratch_gprs: GPRs::new(),
+            scratch_64: (GPRs::new(), [1; NUM_GPRS as _]),
+            scratch_128: (GPRs::new(), [1; NUM_GPRS as _]),
         };
+
         // Give ourselves a few scratch registers to work with, for now.
-        result.release_scratch_gpr(RAX);
-        result.release_scratch_gpr(RCX);
-        result.release_scratch_gpr(RDX);
+        for &scratch in SCRATCH_REGS {
+            result.release(scratch);
+        }
+
         result
     }
 
-    pub fn take_scratch_gpr(&mut self) -> GPR {
-        self.scratch_gprs.take()
+    fn scratch_counts_mut(&mut self, gpr: GPR) -> (u8, &mut (GPRs, [u8; NUM_GPRS as usize])) {
+        match gpr {
+            GPR::Rq(r) => (r, &mut self.scratch_64),
+            GPR::Rx(r) => (r, &mut self.scratch_128),
+        }
     }
 
-    pub fn release_scratch_gpr(&mut self, gpr: GPR) {
-        self.scratch_gprs.release(gpr);
+    fn scratch_counts(&self, gpr: GPR) -> (u8, &(GPRs, [u8; NUM_GPRS as usize])) {
+        match gpr {
+            GPR::Rq(r) => (r, &self.scratch_64),
+            GPR::Rx(r) => (r, &self.scratch_128),
+        }
+    }
+
+    pub fn mark_used(&mut self, gpr: GPR) {
+        let (gpr, scratch_counts) = self.scratch_counts_mut(gpr);
+        scratch_counts.0.mark_used(gpr);
+        scratch_counts.1[gpr as usize] += 1;
+    }
+
+    pub fn num_usages(&self, gpr: GPR) -> u8 {
+        let (gpr, scratch_counts) = self.scratch_counts(gpr);
+        scratch_counts.1[gpr as usize]
+    }
+
+    pub fn take(&mut self, ty: impl Into<GPRType>) -> GPR {
+        let (mk_gpr, scratch_counts) = match ty.into() {
+            GPRType::Rq => (GPR::Rq as fn(_) -> _, &mut self.scratch_64),
+            GPRType::Rx => (GPR::Rx as fn(_) -> _, &mut self.scratch_128),
+        };
+
+        let out = scratch_counts.0.take();
+        scratch_counts.1[out as usize] += 1;
+        mk_gpr(out)
+    }
+
+    pub fn release(&mut self, gpr: GPR) {
+        let (gpr, scratch_counts) = self.scratch_counts_mut(gpr);
+        let c = &mut scratch_counts.1[gpr as usize];
+        *c -= 1;
+        if *c == 0 {
+            scratch_counts.0.release(gpr);
+        }
+    }
+
+    pub fn is_free(&self, gpr: GPR) -> bool {
+        let (gpr, scratch_counts) = self.scratch_counts(gpr);
+        scratch_counts.0.is_free(gpr)
+    }
+
+    pub fn free_64(&self) -> u32 {
+        self.scratch_64.0.free_count()
+    }
+
+    pub fn free_128(&self) -> u32 {
+        self.scratch_128.0.free_count()
     }
 }
 
-/// Describes location of a argument.
-#[derive(Debug)]
-enum ArgLocation {
-    /// Argument is passed via some register.
-    Reg(GPR),
-    /// Value is passed thru the stack.
-    Stack(i32),
+#[derive(Debug, Clone)]
+pub struct CallingConvention {
+    stack_depth: StackDepth,
+    arguments: Vec<CCLoc>,
 }
 
-/// Get a location for an argument at the given position.
-fn abi_loc_for_arg(pos: u32) -> ArgLocation {
-    // TODO: This assumes only system-v calling convention.
-    // In system-v calling convention the first 6 arguments are passed via registers.
-    // All rest arguments are passed on the stack.
-    const ARGS_IN_GPRS: &'static [GPR] = &[RDI, RSI, RDX, RCX, R8, R9];
-
-    if let Some(&reg) = ARGS_IN_GPRS.get(pos as usize) {
-        ArgLocation::Reg(reg)
-    } else {
-        let stack_pos = pos - ARGS_IN_GPRS.len() as u32;
-        // +2 is because the first argument is located right after the saved frame pointer slot
-        // and the incoming return address.
-        let stack_offset = ((stack_pos + 2) * WORD_SIZE) as i32;
-        ArgLocation::Stack(stack_offset)
-    }
-}
-
-/// Records data about the function.
-struct FuncDef {
-    /// Offset to the start of the function. None, until the exact offset is known.
-    ///
-    /// Used to calculate the address for calling this function.
-    /// TODO: This field will not be needed if dynasm gain ability to return `AssemblyOffset` for the
-    /// defined labels.
-    offset: Option<AssemblyOffset>,
-    /// Dynamic label can be used to designate target of calls
-    /// before knowning the actual address of the function.
-    label: DynamicLabel,
-}
-
-impl FuncDef {
-    fn new(asm: &mut Assembler) -> FuncDef {
-        FuncDef {
-            offset: None,
-            label: asm.new_dynamic_label(),
+impl CallingConvention {
+    pub fn function_start(args: impl IntoIterator<Item = CCLoc>) -> Self {
+        CallingConvention {
+            // We start and return the function with stack depth 1 since we must
+            // allow space for the saved return address.
+            stack_depth: StackDepth(1),
+            arguments: Vec::from_iter(args),
         }
     }
 }
 
-pub struct CodeGenSession {
-    assembler: Assembler,
-    func_defs: Vec<FuncDef>,
+// TODO: Combine this with `ValueLocation`?
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum CCLoc {
+    /// Value exists in a register.
+    Reg(GPR),
+    /// Value exists on the stack.
+    Stack(i32),
 }
 
-impl CodeGenSession {
-    pub fn new(func_count: u32) -> Self {
+// TODO: Allow pushing condition codes to stack? We'd have to immediately
+//       materialise them into a register if anything is pushed above them.
+/// Describes location of a value.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ValueLocation {
+    /// Value exists in a register.
+    Reg(GPR),
+    /// Value exists on the stack. Note that this offset is from the rsp as it
+    /// was when we entered the function.
+    Stack(i32),
+    /// Value is a literal
+    Immediate(Value),
+}
+
+impl From<CCLoc> for ValueLocation {
+    fn from(other: CCLoc) -> Self {
+        match other {
+            CCLoc::Reg(r) => ValueLocation::Reg(r),
+            CCLoc::Stack(o) => ValueLocation::Stack(o),
+        }
+    }
+}
+
+impl ValueLocation {
+    fn immediate(self) -> Option<Value> {
+        match self {
+            ValueLocation::Immediate(i) => Some(i),
+            _ => None,
+        }
+    }
+
+    fn imm_i32(self) -> Option<i32> {
+        self.immediate().and_then(Value::as_i32)
+    }
+
+    fn imm_i64(self) -> Option<i64> {
+        self.immediate().and_then(Value::as_i64)
+    }
+
+    fn imm_f32(self) -> Option<wasmparser::Ieee32> {
+        self.immediate().and_then(Value::as_f32)
+    }
+
+    fn imm_f64(self) -> Option<wasmparser::Ieee64> {
+        self.immediate().and_then(Value::as_f64)
+    }
+}
+
+// TODO: This assumes only system-v calling convention.
+// In system-v calling convention the first 6 arguments are passed via registers.
+// All rest arguments are passed on the stack.
+const INTEGER_ARGS_IN_GPRS: &[GPR] = &[RSI, RDX, RCX, R8, R9];
+const INTEGER_RETURN_GPRS: &[GPR] = &[RAX, RDX];
+const FLOAT_ARGS_IN_GPRS: &[GPR] = &[XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7];
+const FLOAT_RETURN_GPRS: &[GPR] = &[XMM0, XMM1];
+// List of scratch registers taken from https://wiki.osdev.org/System_V_ABI
+const SCRATCH_REGS: &[GPR] = &[
+    RSI, RDX, RCX, R8, R9, RAX, R10, R11, XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7, XMM8,
+    XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15,
+];
+const VMCTX: RegId = rq::RDI;
+
+#[must_use]
+#[derive(Debug, Clone)]
+pub struct FunctionEnd {
+    should_generate_epilogue: bool,
+}
+
+pub struct CodeGenSession<'a, M> {
+    assembler: Assembler,
+    pub module_context: &'a M,
+    func_starts: Vec<(Option<AssemblyOffset>, DynamicLabel)>,
+}
+
+impl<'a, M> CodeGenSession<'a, M> {
+    pub fn new(func_count: u32, module_context: &'a M) -> Self {
         let mut assembler = Assembler::new().unwrap();
-        let func_defs = iter::repeat_with(|| FuncDef::new(&mut assembler))
+        let func_starts = iter::repeat_with(|| (None, assembler.new_dynamic_label()))
             .take(func_count as usize)
             .collect::<Vec<_>>();
 
         CodeGenSession {
             assembler,
-            func_defs,
+            func_starts,
+            module_context,
         }
     }
 
-    pub fn new_context(&mut self, func_idx: u32) -> Context {
+    pub fn new_context(&mut self, func_idx: u32) -> Context<'_, M> {
         {
-            let func_start = &mut self.func_defs[func_idx as usize];
+            let func_start = &mut self.func_starts[func_idx as usize];
 
             // At this point we know the exact start address of this function. Save it
             // and define dynamic label at this location.
-            func_start.offset = Some(self.assembler.offset());
-            self.assembler.dynamic_label(func_start.label);
+            func_start.0 = Some(self.assembler.offset());
+            self.assembler.dynamic_label(func_start.1);
         }
 
         Context {
             asm: &mut self.assembler,
-            func_defs: &self.func_defs,
-            regs: Registers::new(),
-            sp_depth: StackDepth(0),
+            func_starts: &self.func_starts,
+            labels: Default::default(),
+            block_state: Default::default(),
+            module_context: self.module_context,
         }
     }
 
@@ -170,57 +508,149 @@ impl CodeGenSession {
             .assembler
             .finalize()
             .map_err(|_asm| Error::Assembler("assembler error".to_owned()))?;
-        let func_defs = self
-            .func_defs
+        let func_starts = self
+            .func_starts
             .iter()
-            .map(|FuncDef { offset, .. }| offset.unwrap())
+            .map(|(offset, _)| offset.unwrap())
             .collect::<Vec<_>>();
         Ok(TranslatedCodeSection {
             exec_buf,
-            func_defs,
+            func_starts,
+            // TODO
+            relocatable_accesses: vec![],
         })
     }
 }
 
+#[derive(Debug)]
+struct RelocateAddress {
+    reg: Option<GPR>,
+    imm: usize,
+}
+
+#[derive(Debug)]
+struct RelocateAccess {
+    position: AssemblyOffset,
+    dst_reg: GPR,
+    address: RelocateAddress,
+}
+
+#[derive(Debug)]
+pub struct UninitializedCodeSection(TranslatedCodeSection);
+
+#[derive(Debug)]
 pub struct TranslatedCodeSection {
     exec_buf: ExecutableBuffer,
-    func_defs: Vec<AssemblyOffset>,
+    func_starts: Vec<AssemblyOffset>,
+    relocatable_accesses: Vec<RelocateAccess>,
 }
 
 impl TranslatedCodeSection {
     pub fn func_start(&self, idx: usize) -> *const u8 {
-        let offset = self.func_defs[idx];
+        let offset = self.func_starts[idx];
         self.exec_buf.ptr(offset)
     }
+
+    pub fn func_range(&self, idx: usize) -> std::ops::Range<usize> {
+        let end = self
+            .func_starts
+            .get(idx + 1)
+            .map(|i| i.0)
+            .unwrap_or(self.exec_buf.len());
+
+        self.func_starts[idx].0..end
+    }
+
+    pub fn funcs<'a>(&'a self) -> impl Iterator<Item = std::ops::Range<usize>> + 'a {
+        (0..self.func_starts.len()).map(move |i| self.func_range(i))
+    }
+
+    pub fn buffer(&self) -> &[u8] {
+        &*self.exec_buf
+    }
+
+    pub fn disassemble(&self) {
+        ::disassemble::disassemble(&*self.exec_buf).unwrap();
+    }
 }
 
-pub struct Context<'a> {
-    asm: &'a mut Assembler,
-    func_defs: &'a Vec<FuncDef>,
+/// A value on the logical stack. The logical stack is the value stack as it
+/// is visible to the WebAssembly, whereas the physical stack is the stack as
+/// it exists on the machine (i.e. as offsets in memory relative to `rsp`).
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum StackValue {
+    /// This value has a "real" location, either in a register, on the stack,
+    /// in an immediate, etc.
+    Value(ValueLocation),
+    /// This value is on the physical stack and so should be accessed
+    /// with the `pop` instruction.
+    // TODO: This complicates a lot of our code, it'd be great if we could get rid of it.
+    Pop,
+}
+
+impl StackValue {
+    /// Returns either the location that this value can be accessed at
+    /// if possible. If this value is `Pop`, you can only access it by
+    /// popping the physical stack and so this function returns `None`.
+    ///
+    /// Of course, we could calculate the location of the value on the
+    /// physical stack, but that would be unncessary computation for
+    /// our usecases.
+    fn location(&self) -> Option<ValueLocation> {
+        match *self {
+            StackValue::Value(loc) => Some(loc),
+            StackValue::Pop => None,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct BlockState {
+    stack: Stack,
+    depth: StackDepth,
     regs: Registers,
+}
+
+type Stack = Vec<ValueLocation>;
+
+pub enum MemoryAccessMode {
+    /// This is slower than using `Unchecked` mode, but works in
+    /// any scenario (the most important scenario being when we're
+    /// running on a system that can't index much more memory than
+    /// the Wasm).
+    Checked,
+    /// This means that checks are _not emitted by the compiler_!
+    /// If you're using WebAssembly to run untrusted code, you
+    /// _must_ delegate bounds checking somehow (probably by
+    /// allocating 2^33 bytes of memory with the second half set
+    /// to unreadable/unwriteable/unexecutable)
+    Unchecked,
+}
+
+// TODO: We can share one trap/constant for all functions by reusing this struct
+#[derive(Default)]
+struct Labels {
+    trap: Option<Label>,
+    ret: Option<Label>,
+    neg_const_f32: Option<Label>,
+    neg_const_f64: Option<Label>,
+}
+
+pub struct Context<'a, M> {
+    asm: &'a mut Assembler,
+    module_context: &'a M,
+    func_starts: &'a Vec<(Option<AssemblyOffset>, DynamicLabel)>,
     /// Each push and pop on the value stack increments or decrements this value by 1 respectively.
-    sp_depth: StackDepth,
+    pub block_state: BlockState,
+    labels: Labels,
 }
 
 /// Label in code.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct Label(DynamicLabel);
 
-/// Create a new undefined label.
-pub fn create_label(ctx: &mut Context) -> Label {
-    Label(ctx.asm.new_dynamic_label())
-}
-
-/// Define the given label at the current position.
-///
-/// Multiple labels can be defined at the same position. However, a label
-/// can be defined only once.
-pub fn define_label(ctx: &mut Context, label: Label) {
-    ctx.asm.dynamic_label(label.0);
-}
-
 /// Offset from starting value of SP counted in words.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq)]
 pub struct StackDepth(u32);
 
 impl StackDepth {
@@ -233,202 +663,2215 @@ impl StackDepth {
     }
 }
 
-pub fn current_stack_depth(ctx: &Context) -> StackDepth {
-    ctx.sp_depth
-}
+macro_rules! unop {
+    ($name:ident, $instr:ident, $reg_ty:ident, $typ:ty, $const_fallback:expr) => {
+        pub fn $name(&mut self) {
+            let val = self.pop();
 
-pub fn restore_stack_depth(ctx: &mut Context, stack_depth: StackDepth) {
-    ctx.sp_depth = stack_depth;
-}
+            let out_val = match val {
+                ValueLocation::Immediate(imm) =>
+                    ValueLocation::Immediate(
+                        ($const_fallback(imm.as_int().unwrap() as $typ) as $typ).into()
+                    ),
+                ValueLocation::Stack(offset) => {
+                    let offset = self.adjusted_offset(offset);
+                    let temp = self.block_state.regs.take(Type::for_::<$typ>());
+                    dynasm!(self.asm
+                        ; $instr $reg_ty(temp.rq().unwrap()), [rsp + offset]
+                    );
+                    ValueLocation::Reg(temp)
+                }
+                ValueLocation::Reg(reg) => {
+                    let temp = self.block_state.regs.take(Type::for_::<$typ>());
+                    dynasm!(self.asm
+                        ; $instr $reg_ty(temp.rq().unwrap()), $reg_ty(reg.rq().unwrap())
+                    );
+                    ValueLocation::Reg(temp)
+                }
+            };
 
-fn push_i32(ctx: &mut Context, gpr: GPR) {
-    // For now, do an actual push (and pop below). In the future, we could
-    // do on-the-fly register allocation here.
-    ctx.sp_depth.reserve(1);
-    dynasm!(ctx.asm
-        ; push Rq(gpr)
-    );
-    ctx.regs.release_scratch_gpr(gpr);
-}
-
-fn pop_i32(ctx: &mut Context) -> GPR {
-    ctx.sp_depth.free(1);
-    let gpr = ctx.regs.take_scratch_gpr();
-    dynasm!(ctx.asm
-        ; pop Rq(gpr)
-    );
-    gpr
-}
-
-pub fn add_i32(ctx: &mut Context) {
-    let op0 = pop_i32(ctx);
-    let op1 = pop_i32(ctx);
-    dynasm!(ctx.asm
-        ; add Rd(op0), Rd(op1)
-    );
-    push_i32(ctx, op0);
-    ctx.regs.release_scratch_gpr(op1);
-}
-
-fn sp_relative_offset(ctx: &mut Context, slot_idx: u32) -> i32 {
-    ((ctx.sp_depth.0 as i32) + slot_idx as i32) * WORD_SIZE as i32
-}
-
-pub fn get_local_i32(ctx: &mut Context, local_idx: u32) {
-    let gpr = ctx.regs.take_scratch_gpr();
-    let offset = sp_relative_offset(ctx, local_idx);
-    dynasm!(ctx.asm
-        ; mov Rq(gpr), [rsp + offset]
-    );
-    push_i32(ctx, gpr);
-}
-
-pub fn set_local_i32(ctx: &mut Context, local_idx: u32) {
-    let gpr = pop_i32(ctx);
-    let offset = sp_relative_offset(ctx, local_idx);
-    dynasm!(ctx.asm
-        ; mov [rsp + offset], Rq(gpr)
-    );
-    ctx.regs.release_scratch_gpr(gpr);
-}
-
-pub fn literal_i32(ctx: &mut Context, imm: i32) {
-    let gpr = ctx.regs.take_scratch_gpr();
-    dynasm!(ctx.asm
-        ; mov Rd(gpr), imm
-    );
-    push_i32(ctx, gpr);
-}
-
-pub fn relop_eq_i32(ctx: &mut Context) {
-    let right = pop_i32(ctx);
-    let left = pop_i32(ctx);
-    let result = ctx.regs.take_scratch_gpr();
-    dynasm!(ctx.asm
-        ; xor Rq(result), Rq(result)
-        ; cmp Rd(left), Rd(right)
-        ; sete Rb(result)
-    );
-    push_i32(ctx, result);
-    ctx.regs.release_scratch_gpr(left);
-    ctx.regs.release_scratch_gpr(right);
-}
-
-/// Pops i32 predicate and branches to the specified label
-/// if the predicate is equal to zero.
-pub fn pop_and_breq(ctx: &mut Context, label: Label) {
-    let predicate = pop_i32(ctx);
-    dynasm!(ctx.asm
-        ; test Rd(predicate), Rd(predicate)
-        ; je =>label.0
-    );
-    ctx.regs.release_scratch_gpr(predicate);
-}
-
-/// Branch unconditionally to the specified label.
-pub fn br(ctx: &mut Context, label: Label) {
-    dynasm!(ctx.asm
-        ; jmp =>label.0
-    );
-}
-
-pub fn prepare_return_value(ctx: &mut Context) {
-    let ret_gpr = pop_i32(ctx);
-    if ret_gpr != RAX {
-        dynasm!(ctx.asm
-            ; mov Rq(RAX), Rq(ret_gpr)
-        );
-        ctx.regs.release_scratch_gpr(ret_gpr);
+            self.push(out_val);
+        }
     }
 }
 
-pub fn copy_incoming_arg(ctx: &mut Context, arg_pos: u32) {
-    let loc = abi_loc_for_arg(arg_pos);
+// TODO: Support immediate `count` parameters
+macro_rules! shift {
+    ($name:ident, $reg_ty:ident, $instr:ident, $const_fallback:expr, $ty:expr) => {
+        pub fn $name(&mut self) {
+            enum RestoreRcx {
+                MoveValBack(GPR),
+                PopRcx,
+            }
 
-    // First, ensure the argument is in a register.
-    let reg = match loc {
-        ArgLocation::Reg(reg) => reg,
-        ArgLocation::Stack(offset) => {
-            assert!(
-                ctx.regs.scratch_gprs.is_free(RAX),
-                "we assume that RAX can be used as a scratch register for now",
+            let mut count = self.pop();
+            let mut val = self.pop();
+
+            if val == ValueLocation::Reg(RCX) {
+                val = ValueLocation::Reg(self.into_temp_reg($ty, val));
+            }
+
+            // TODO: Maybe allocate `RCX`, write `count` to it and then free `count`.
+            //       Once we've implemented refcounting this will do the right thing
+            //       for free.
+            let temp_rcx = match count {
+                ValueLocation::Reg(RCX) => {None}
+                other => {
+                    let out = if self.block_state.regs.is_free(RCX) {
+                        None
+                    } else {
+                        let new_reg = self.block_state.regs.take(I32);
+                        dynasm!(self.asm
+                            ; mov Rq(new_reg.rq().unwrap()), rcx
+                        );
+                        Some(new_reg)
+                    };
+
+                    match other {
+                        ValueLocation::Reg(gpr) => {
+                            dynasm!(self.asm
+                                ; mov cl, Rb(gpr.rq().unwrap())
+                            );
+                        }
+                        ValueLocation::Stack(offset) => {
+                            let offset = self.adjusted_offset(offset);
+                            dynasm!(self.asm
+                                ; mov cl, [rsp + offset]
+                            );
+                        }
+                        ValueLocation::Immediate(imm) => {
+                            dynasm!(self.asm
+                                ; mov cl, imm.as_int().unwrap() as i8
+                            );
+                        }
+                    }
+
+                    out
+                }
+            };
+
+            self.free_value(count);
+            self.block_state.regs.mark_used(RCX);
+            count = ValueLocation::Reg(RCX);
+
+            let reg = self.into_reg($ty, val);
+
+            dynasm!(self.asm
+                ; $instr $reg_ty(reg.rq().unwrap()), cl
             );
-            dynasm!(ctx.asm
-                ; mov Rq(RAX), [rsp + offset]
+
+            self.free_value(count);
+
+            if let Some(gpr) = temp_rcx {
+                dynasm!(self.asm
+                    ; mov rcx, Rq(gpr.rq().unwrap())
+                );
+                self.block_state.regs.release(gpr);
+            }
+
+            self.push(ValueLocation::Reg(reg));
+        }
+    }
+}
+
+macro_rules! cmp_i32 {
+    ($name:ident, $instr:ident, $reverse_instr:ident, $const_fallback:expr) => {
+        pub fn $name(&mut self) {
+            let right = self.pop();
+            let mut left = self.pop();
+
+            let out = if let Some(i) = left.imm_i32() {
+                match right {
+                    ValueLocation::Stack(offset) => {
+                        let result = self.block_state.regs.take(I32);
+                        let offset = self.adjusted_offset(offset);
+
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp DWORD [rsp + offset], i
+                            ; $reverse_instr Rb(result.rq().unwrap())
+                        );
+                        ValueLocation::Reg(result)
+                    }
+                    ValueLocation::Reg(rreg) => {
+                        let result = self.block_state.regs.take(I32);
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp Rd(rreg.rq().unwrap()), i
+                            ; $reverse_instr Rb(result.rq().unwrap())
+                        );
+                        ValueLocation::Reg(result)
+                    }
+                    ValueLocation::Immediate(right) => {
+                        ValueLocation::Immediate(
+                            (if $const_fallback(i, right.as_i32().unwrap()) {
+                                1i32
+                            } else {
+                                0i32
+                            }).into()
+                        )
+                    }
+                }
+            } else {
+                let lreg = self.into_reg(I32, left);
+                // TODO: Make `into_reg` take an `&mut`?
+                left = ValueLocation::Reg(lreg);
+
+                let result = self.block_state.regs.take(I32);
+
+                match right {
+                    ValueLocation::Stack(offset) => {
+                        let offset = self.adjusted_offset(offset);
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp Rd(lreg.rq().unwrap()), [rsp + offset]
+                            ; $instr Rb(result.rq().unwrap())
+                        );
+                    }
+                    ValueLocation::Reg(rreg) => {
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp Rd(lreg.rq().unwrap()), Rd(rreg.rq().unwrap())
+                            ; $instr Rb(result.rq().unwrap())
+                        );
+                    }
+                    ValueLocation::Immediate(i) => {
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp Rd(lreg.rq().unwrap()), i.as_i32().unwrap()
+                            ; $instr Rb(result.rq().unwrap())
+                        );
+                    }
+                }
+
+                ValueLocation::Reg(result)
+            };
+
+            self.free_value(left);
+            self.free_value(right);
+
+            self.push(out);
+        }
+    }
+}
+
+macro_rules! cmp_i64 {
+    ($name:ident, $instr:ident, $reverse_instr:ident, $const_fallback:expr) => {
+        pub fn $name(&mut self) {
+            let right = self.pop();
+            let mut left = self.pop();
+
+            let out = if let Some(i) = left.imm_i64() {
+                match right {
+                    ValueLocation::Stack(offset) => {
+                        let result = self.block_state.regs.take(I32);
+                        let offset = self.adjusted_offset(offset);
+                        if let Some(i) = i.try_into() {
+                            dynasm!(self.asm
+                                ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                                ; cmp QWORD [rsp + offset], i
+                                ; $reverse_instr Rb(result.rq().unwrap())
+                            );
+                        } else {
+                            unimplemented!("Unsupported `cmp` with large 64-bit immediate operand");
+                        }
+                        ValueLocation::Reg(result)
+                    }
+                    ValueLocation::Reg(rreg) => {
+                        let result = self.block_state.regs.take(I32);
+                        if let Some(i) = i.try_into() {
+                            dynasm!(self.asm
+                                ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                                ; cmp Rq(rreg.rq().unwrap()), i
+                                ; $reverse_instr Rb(result.rq().unwrap())
+                            );
+                        } else {
+                            unimplemented!("Unsupported `cmp` with large 64-bit immediate operand");
+                        }
+                        ValueLocation::Reg(result)
+                    }
+                    ValueLocation::Immediate(right) => {
+                        ValueLocation::Immediate(
+                            (if $const_fallback(i, right.as_i64().unwrap()) {
+                                1i32
+                            } else {
+                                0i32
+                            }).into()
+                        )
+                    }
+                }
+            } else {
+                let lreg = self.into_reg(I64, left);
+                left = ValueLocation::Reg(lreg);
+
+                let result = self.block_state.regs.take(I32);
+
+                match right {
+                    ValueLocation::Stack(offset) => {
+                        let offset = self.adjusted_offset(offset);
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp Rq(lreg.rq().unwrap()), [rsp + offset]
+                            ; $instr Rb(result.rq().unwrap())
+                        );
+                    }
+                    ValueLocation::Reg(rreg) => {
+                        dynasm!(self.asm
+                            ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                            ; cmp Rq(lreg.rq().unwrap()), Rq(rreg.rq().unwrap())
+                            ; $instr Rb(result.rq().unwrap())
+                        );
+                    }
+                    ValueLocation::Immediate(i) => {
+                        let i = i.as_i64().unwrap();
+                        if let Some(i) = i.try_into() {
+                            dynasm!(self.asm
+                                ; xor Rd(result.rq().unwrap()), Rd(result.rq().unwrap())
+                                ; cmp Rq(lreg.rq().unwrap()), i
+                                ; $instr Rb(result.rq().unwrap())
+                            );
+                        } else {
+                            unimplemented!("Unsupported `cmp` with large 64-bit immediate operand");
+                        }
+                    }
+                }
+
+                ValueLocation::Reg(result)
+            };
+
+            self.free_value(left);
+            self.free_value(right);
+            self.push(out);
+        }
+    }
+}
+
+macro_rules! cmp_f32 {
+    ($name:ident, $reverse_name:ident, $instr:ident, $const_fallback:expr) => {
+        cmp_float!(
+            comiss,
+            f32,
+            imm_f32,
+            $name,
+            $reverse_name,
+            $instr,
+            $const_fallback
+        );
+    };
+}
+
+macro_rules! cmp_f64 {
+    ($name:ident, $reverse_name:ident, $instr:ident, $const_fallback:expr) => {
+        cmp_float!(
+            comisd,
+            f64,
+            imm_f64,
+            $name,
+            $reverse_name,
+            $instr,
+            $const_fallback
+        );
+    };
+}
+
+macro_rules! cmp_float {
+    (@helper $cmp_instr:ident, $ty:ty, $imm_fn:ident, $self:expr, $left:expr, $right:expr, $instr:ident, $const_fallback:expr) => {{
+        let (left, right, this) = ($left, $right, $self);
+        if let (Some(left), Some(right)) = (left.$imm_fn(), right.$imm_fn()) {
+            if $const_fallback(<$ty>::from_bits(left.bits()), <$ty>::from_bits(right.bits())) {
+                ValueLocation::Immediate(1i32.into())
+            } else {
+                ValueLocation::Immediate(0i32.into())
+            }
+        } else {
+            let lreg = this.into_reg(GPRType::Rx, *left);
+            *left = ValueLocation::Reg(lreg);
+            let result = this.block_state.regs.take(I32);
+
+            match right {
+                ValueLocation::Stack(offset) => {
+                    let offset = this.adjusted_offset(*offset);
+
+                    dynasm!(this.asm
+                        ; xor Rq(result.rq().unwrap()), Rq(result.rq().unwrap())
+                        ; $cmp_instr Rx(lreg.rx().unwrap()), [rsp + offset]
+                        ; $instr Rb(result.rq().unwrap())
+                    );
+                }
+                right => {
+                    let rreg = this.into_reg(GPRType::Rx, *right);
+                    *right = ValueLocation::Reg(rreg);
+
+                    dynasm!(this.asm
+                        ; xor Rq(result.rq().unwrap()), Rq(result.rq().unwrap())
+                        ; $cmp_instr Rx(lreg.rx().unwrap()), Rx(rreg.rx().unwrap())
+                        ; $instr Rb(result.rq().unwrap())
+                    );
+                }
+            }
+
+            ValueLocation::Reg(result)
+        }
+    }};
+    ($cmp_instr:ident, $ty:ty, $imm_fn:ident, $name:ident, $reverse_name:ident, $instr:ident, $const_fallback:expr) => {
+        pub fn $name(&mut self) {
+            let mut right = self.pop();
+            let mut left = self.pop();
+
+            let out = cmp_float!(@helper
+                $cmp_instr,
+                $ty,
+                $imm_fn,
+                &mut *self,
+                &mut left,
+                &mut right,
+                $instr,
+                $const_fallback
             );
-            RAX
+
+            self.free_value(left);
+            self.free_value(right);
+
+            self.push(out);
+        }
+
+        pub fn $reverse_name(&mut self) {
+            let mut right = self.pop();
+            let mut left = self.pop();
+
+            let out = cmp_float!(@helper
+                $cmp_instr,
+                $ty,
+                $imm_fn,
+                &mut *self,
+                &mut right,
+                &mut left,
+                $instr,
+                $const_fallback
+            );
+
+            self.free_value(left);
+            self.free_value(right);
+
+            self.push(out);
         }
     };
-
-    // And then move a value from a register into local variable area on the stack.
-    let offset = sp_relative_offset(ctx, arg_pos);
-    dynasm!(ctx.asm
-        ; mov [rsp + offset], Rq(reg)
-    );
 }
 
-pub fn pass_outgoing_args(ctx: &mut Context, arity: u32) {
-    for arg_pos in (0..arity).rev() {
-        ctx.sp_depth.free(1);
+macro_rules! binop_i32 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        binop!(
+            $name,
+            $instr,
+            $const_fallback,
+            Rd,
+            rq,
+            I32,
+            imm_i32,
+            |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm
+                ; $instr Rd(op1.rq().unwrap()), i
+            )
+        );
+    };
+}
 
-        let loc = abi_loc_for_arg(arg_pos);
-        match loc {
-            ArgLocation::Reg(gpr) => {
-                dynasm!(ctx.asm
-                    ; pop Rq(gpr)
-                );
+macro_rules! commutative_binop_i32 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        commutative_binop!(
+            $name,
+            $instr,
+            $const_fallback,
+            Rd,
+            rq,
+            I32,
+            imm_i32,
+            |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm
+                ; $instr Rd(op1.rq().unwrap()), i
+            )
+        );
+    };
+}
+
+macro_rules! binop_i64 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        binop!(
+            $name,
+            $instr,
+            $const_fallback,
+            Rq,
+            rq,
+            I64,
+            imm_i64,
+            |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm
+                ; $instr Rq(op1.rq().unwrap()), i
+            )
+        );
+    };
+}
+
+macro_rules! commutative_binop_i64 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        commutative_binop!(
+            $name,
+            $instr,
+            $const_fallback,
+            Rq,
+            rq,
+            I64,
+            imm_i64,
+            |this: &mut Context<_>, op1: GPR, i| dynasm!(this.asm
+                ; $instr Rq(op1.rq().unwrap()), i
+            )
+        );
+    };
+}
+
+macro_rules! binop_f32 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        binop!(
+            $name,
+            $instr,
+            |a: wasmparser::Ieee32, b: wasmparser::Ieee32| wasmparser::Ieee32(
+                $const_fallback(f32::from_bits(a.bits()), f32::from_bits(b.bits())).to_bits()
+            ),
+            Rx,
+            rx,
+            F32,
+            imm_f32,
+            |_, _, _| unreachable!()
+        );
+    };
+}
+
+macro_rules! commutative_binop_f32 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        commutative_binop!(
+            $name,
+            $instr,
+            |a: wasmparser::Ieee32, b: wasmparser::Ieee32| wasmparser::Ieee32(
+                $const_fallback(f32::from_bits(a.bits()), f32::from_bits(b.bits())).to_bits()
+            ),
+            Rx,
+            rx,
+            F32,
+            imm_f32,
+            |_, _, _| unreachable!()
+        );
+    };
+}
+
+macro_rules! binop_f64 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        binop!(
+            $name,
+            $instr,
+            |a: wasmparser::Ieee64, b: wasmparser::Ieee64| wasmparser::Ieee64(
+                $const_fallback(f64::from_bits(a.bits()), f64::from_bits(b.bits())).to_bits()
+            ),
+            Rx,
+            rx,
+            F64,
+            imm_f64,
+            |_, _, _| unreachable!()
+        );
+    };
+}
+
+macro_rules! commutative_binop_f64 {
+    ($name:ident, $instr:ident, $const_fallback:expr) => {
+        commutative_binop!(
+            $name,
+            $instr,
+            |a: wasmparser::Ieee64, b: wasmparser::Ieee64| wasmparser::Ieee64(
+                $const_fallback(f64::from_bits(a.bits()), f64::from_bits(b.bits())).to_bits()
+            ),
+            Rx,
+            rx,
+            F64,
+            imm_f64,
+            |_, _, _| unreachable!()
+        );
+    };
+}
+macro_rules! commutative_binop {
+    ($name:ident, $instr:ident, $const_fallback:expr, $reg_ty:ident, $reg_fn:ident, $ty:expr, $imm_fn:ident, $direct_imm:expr) => {
+        binop!(
+            $name,
+            $instr,
+            $const_fallback,
+            $reg_ty,
+            $reg_fn,
+            $ty,
+            $imm_fn,
+            $direct_imm,
+            |op1: ValueLocation, op0: ValueLocation| match op1 {
+                ValueLocation::Reg(_) => (op1, op0),
+                _ => {
+                    if op0.immediate().is_some() {
+                        (op1, op0)
+                    } else {
+                        (op0, op1)
+                    }
+                }
             }
-            _ => unimplemented!("don't know how to pass argument {} via {:?}", arg_pos, loc),
+        );
+    };
+}
+
+macro_rules! binop {
+    ($name:ident, $instr:ident, $const_fallback:expr, $reg_ty:ident, $reg_fn:ident, $ty:expr, $imm_fn:ident, $direct_imm:expr) => {
+        binop!($name, $instr, $const_fallback, $reg_ty, $reg_fn, $ty, $imm_fn, $direct_imm, |a, b| (a, b));
+    };
+    ($name:ident, $instr:ident, $const_fallback:expr, $reg_ty:ident, $reg_fn:ident, $ty:expr, $imm_fn:ident, $direct_imm:expr, $map_op:expr) => {
+        pub fn $name(&mut self) {
+            let op0 = self.pop();
+            let op1 = self.pop();
+
+            if let Some(i1) = op1.$imm_fn() {
+                if let Some(i0) = op0.$imm_fn() {
+                    self.block_state.stack.push(ValueLocation::Immediate($const_fallback(i1, i0).into()));
+                    return;
+                }
+            }
+
+            let (op1, op0) = $map_op(op1, op0);
+            let op1 = self.into_temp_reg($ty, op1);
+
+            match op0 {
+                ValueLocation::Reg(reg) => {
+                    dynasm!(self.asm
+                        ; $instr $reg_ty(op1.$reg_fn().unwrap()), $reg_ty(reg.$reg_fn().unwrap())
+                    );
+                }
+                ValueLocation::Stack(offset) => {
+                    let offset = self.adjusted_offset(offset);
+                    dynasm!(self.asm
+                        ; $instr $reg_ty(op1.$reg_fn().unwrap()), [rsp + offset]
+                    );
+                }
+                ValueLocation::Immediate(i) => {
+                    if let Some(i) = i.as_int().and_then(|i| i.try_into()) {
+                        $direct_imm(self, op1, i);
+                    } else {
+                        let scratch = self.block_state.regs.take($ty);
+                        self.immediate_to_reg(scratch, i);
+
+                        dynasm!(self.asm
+                            ; $instr $reg_ty(op1.$reg_fn().unwrap()), $reg_ty(scratch.$reg_fn().unwrap())
+                        );
+
+                        self.block_state.regs.release(scratch);
+                    }
+                }
+            }
+
+            self.free_value(op0);
+            self.push(ValueLocation::Reg(op1));
         }
     }
 }
 
-pub fn call_direct(ctx: &mut Context, index: u32, return_arity: u32) {
-    assert!(return_arity == 0 || return_arity == 1);
+macro_rules! load {
+    ($name:ident, $reg_ty:ident, $instruction_name:expr, $out_ty:expr) => {
+        pub fn $name(&mut self, offset: u32) -> Result<(), Error> {
+            fn load_to_reg<_M: ModuleContext>(
+                ctx: &mut Context<_M>,
+                dst: GPR,
+                (offset, runtime_offset): (i32, Result<i32, GPR>)
+            ) {
+                let vmctx_mem_ptr_offset = ctx.module_context.offset_of_memory_ptr() as i32;
+                let mem_ptr_reg = ctx.block_state.regs.take(I64);
+                dynasm!(ctx.asm
+                    ; mov Rq(mem_ptr_reg.rq().unwrap()), [Rq(VMCTX) + vmctx_mem_ptr_offset]
+                );
+                match runtime_offset {
+                    Ok(imm) => {
+                        dynasm!(ctx.asm
+                            ; mov $reg_ty(dst.rq().unwrap()), [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm]
+                        );
+                    }
+                    Err(offset_reg) => {
+                        dynasm!(ctx.asm
+                            ; mov $reg_ty(dst.rq().unwrap()), [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset]
+                        );
+                    }
+                }
+                ctx.block_state.regs.release(mem_ptr_reg);
+            }
 
-    let label = &ctx.func_defs[index as usize].label;
-    dynasm!(ctx.asm
-        ; call =>*label
-    );
+            assert!(offset <= i32::max_value() as u32);
 
-    if return_arity == 1 {
-        dynasm!(ctx.asm
-            ; push rax
-        );
-        ctx.sp_depth.reserve(1);
+            let base = self.pop();
+
+            let temp = self.block_state.regs.take($out_ty);
+
+            match base {
+                ValueLocation::Immediate(i) => {
+                    load_to_reg(self, temp, (offset as _, Ok(i.as_i32().unwrap())));
+                }
+                base => {
+                    let gpr = self.into_reg(I32, base);
+                    load_to_reg(self, temp, (offset as _, Err(gpr)));
+                    self.block_state.regs.release(gpr);
+                }
+            }
+
+            self.push(ValueLocation::Reg(temp));
+
+            Ok(())
+        }
     }
 }
 
-pub fn prologue(ctx: &mut Context, stack_slots: u32) {
-    // Align stack slots to the nearest even number. This is required
-    // by x86-64 ABI.
-    let aligned_stack_slots = (stack_slots + 1) & !1;
+macro_rules! store {
+    ($name:ident, $reg_ty:ident, $size:ident, $instruction_name:expr, $in_ty:expr) => {
+        pub fn $name(&mut self, offset: u32) -> Result<(), Error> {
+            fn store_from_reg<_M: ModuleContext>(
+                ctx: &mut Context<_M>,
+                src: GPR,
+                (offset, runtime_offset): (i32, Result<i32, GPR>)
+            ) {
+                let vmctx_mem_ptr_offset = ctx.module_context.offset_of_memory_ptr() as i32;
+                let mem_ptr_reg = ctx.block_state.regs.take(I64);
+                dynasm!(ctx.asm
+                    ; mov Rq(mem_ptr_reg.rq().unwrap()), [Rq(VMCTX) + vmctx_mem_ptr_offset]
+                );
+                match runtime_offset {
+                    Ok(imm) => {
+                        dynasm!(ctx.asm
+                            ; mov [Rq(mem_ptr_reg.rq().unwrap()) + offset + imm], $reg_ty(src.rq().unwrap())
+                        );
+                    }
+                    Err(offset_reg) => {
+                        dynasm!(ctx.asm
+                            ; mov [Rq(mem_ptr_reg.rq().unwrap()) + Rq(offset_reg.rq().unwrap()) + offset], $reg_ty(src.rq().unwrap())
+                        );
+                    }
+                }
+                ctx.block_state.regs.release(mem_ptr_reg);
+            }
 
-    let framesize: i32 = aligned_stack_slots as i32 * WORD_SIZE as i32;
-    dynasm!(ctx.asm
-        ; push rbp
-        ; mov rbp, rsp
-        ; sub rsp, framesize
-    );
-    ctx.sp_depth.reserve(aligned_stack_slots - stack_slots);
+            assert!(offset <= i32::max_value() as u32);
+
+            let src = self.pop();
+            let base = self.pop();
+
+            let src_reg = self.into_reg($in_ty, src);
+            // TODO
+            debug_assert!(stringify!($reg_ty) == "Rq" || stringify!($reg_ty) == "Rd");
+
+            match base {
+                ValueLocation::Immediate(i) => {
+                    store_from_reg(self, src_reg, (offset as i32, Ok(i.as_i32().unwrap())));
+                }
+                base => {
+                    let gpr = self.into_reg(I32, base);
+                    store_from_reg(self, src_reg, (offset as i32, Err(gpr)));
+                    self.block_state.regs.release(gpr);
+                }
+            }
+
+            self.block_state.regs.release(src_reg);
+
+            Ok(())
+        }
+    }
 }
 
-pub fn epilogue(ctx: &mut Context) {
-    // TODO: This doesn't work with stack alignment.
-    // assert_eq!(
-    //     ctx.sp_depth,
-    //     StackDepth(0),
-    //     "imbalanced pushes and pops detected"
-    // );
-    dynasm!(ctx.asm
-        ; mov rsp, rbp
-        ; pop rbp
-        ; ret
-    );
+trait TryInto<O> {
+    fn try_into(self) -> Option<O>;
 }
 
-pub fn trap(ctx: &mut Context) {
-    dynasm!(ctx.asm
-        ; ud2
-    );
+impl TryInto<i64> for u64 {
+    fn try_into(self) -> Option<i64> {
+        let max = i64::max_value() as u64;
+
+        if self <= max {
+            Some(self as i64)
+        } else {
+            None
+        }
+    }
 }
+
+impl TryInto<i32> for i64 {
+    fn try_into(self) -> Option<i32> {
+        let min = i32::min_value() as i64;
+        let max = i32::max_value() as i64;
+
+        if self >= min && self <= max {
+            Some(self as i32)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct VirtualCallingConvention {
+    stack: Stack,
+    depth: StackDepth,
+}
+
+impl<M: ModuleContext> Context<'_, M> {
+    pub fn debug(&mut self, d: std::fmt::Arguments) {
+        asm_println!(self.asm, "{}", d);
+    }
+
+    pub fn virtual_calling_convention(&self) -> VirtualCallingConvention {
+        VirtualCallingConvention {
+            stack: self.block_state.stack.clone(),
+            depth: self.block_state.depth,
+        }
+    }
+
+    /// Create a new undefined label.
+    pub fn create_label(&mut self) -> Label {
+        Label(self.asm.new_dynamic_label())
+    }
+
+    pub fn define_host_fn(&mut self, host_fn: *const u8) {
+        dynasm!(self.asm
+            ; mov rax, QWORD host_fn as i64
+            ; call rax
+            ; ret
+        );
+    }
+
+    fn adjusted_offset(&self, offset: i32) -> i32 {
+        (self.block_state.depth.0 as i32 + offset) * WORD_SIZE as i32
+    }
+
+    cmp_i32!(i32_eq, sete, sete, |a, b| a == b);
+    cmp_i32!(i32_neq, setne, setne, |a, b| a != b);
+    // `dynasm-rs` inexplicably doesn't support setb but `setnae` (and `setc`) are synonymous
+    cmp_i32!(i32_lt_u, setnae, seta, |a, b| (a as u32) < (b as u32));
+    cmp_i32!(i32_le_u, setbe, setae, |a, b| (a as u32) <= (b as u32));
+    cmp_i32!(i32_gt_u, seta, setnae, |a, b| (a as u32) > (b as u32));
+    cmp_i32!(i32_ge_u, setae, setna, |a, b| (a as u32) >= (b as u32));
+    cmp_i32!(i32_lt_s, setl, setnle, |a, b| a < b);
+    cmp_i32!(i32_le_s, setle, setnl, |a, b| a <= b);
+    cmp_i32!(i32_gt_s, setg, setnge, |a, b| a > b);
+    cmp_i32!(i32_ge_s, setge, setng, |a, b| a >= b);
+
+    cmp_i64!(i64_eq, sete, sete, |a, b| a == b);
+    cmp_i64!(i64_neq, setne, setne, |a, b| a != b);
+    // `dynasm-rs` inexplicably doesn't support setb but `setnae` (and `setc`) are synonymous
+    cmp_i64!(i64_lt_u, setnae, seta, |a, b| (a as u64) < (b as u64));
+    cmp_i64!(i64_le_u, setbe, setae, |a, b| (a as u64) <= (b as u64));
+    cmp_i64!(i64_gt_u, seta, setnae, |a, b| (a as u64) > (b as u64));
+    cmp_i64!(i64_ge_u, setae, setna, |a, b| (a as u64) >= (b as u64));
+    cmp_i64!(i64_lt_s, setl, setnle, |a, b| a < b);
+    cmp_i64!(i64_le_s, setle, setnl, |a, b| a <= b);
+    cmp_i64!(i64_gt_s, setg, setnge, |a, b| a > b);
+    cmp_i64!(i64_ge_s, setge, setng, |a, b| a >= b);
+
+    cmp_f32!(f32_gt, f32_lt, seta, |a, b| a > b);
+    cmp_f32!(f32_ge, f32_le, setnc, |a, b| a >= b);
+
+    cmp_f64!(f64_gt, f64_lt, seta, |a, b| a > b);
+    cmp_f64!(f64_ge, f64_le, setnc, |a, b| a >= b);
+
+    // TODO: Should we do this logic in `eq` and just have this delegate to `eq`?
+    //       That would mean that `eqz` and `eq` with a const 0 argument don't
+    //       result in different code. It would also allow us to generate better
+    //       code for `neq` and `gt_u` with const 0 operand
+    pub fn i32_eqz(&mut self) {
+        let val = self.pop();
+
+        if let ValueLocation::Immediate(Value::I32(i)) = val {
+            self.push(ValueLocation::Immediate(
+                (if i == 0 { 1i32 } else { 0 }).into(),
+            ));
+            return;
+        }
+
+        let reg = self.into_reg(I32, val);
+        let out = self.block_state.regs.take(I32);
+
+        dynasm!(self.asm
+            ; xor Rd(out.rq().unwrap()), Rd(out.rq().unwrap())
+            ; test Rd(reg.rq().unwrap()), Rd(reg.rq().unwrap())
+            ; setz Rb(out.rq().unwrap())
+        );
+
+        self.block_state.regs.release(reg);
+
+        self.push(ValueLocation::Reg(out));
+    }
+
+    pub fn i64_eqz(&mut self) {
+        let val = self.pop();
+
+        if let ValueLocation::Immediate(Value::I64(i)) = val {
+            self.push(ValueLocation::Immediate(
+                (if i == 0 { 1i32 } else { 0 }).into(),
+            ));
+            return;
+        }
+
+        let reg = self.into_reg(I64, val);
+        let out = self.block_state.regs.take(I64);
+
+        dynasm!(self.asm
+            ; xor Rd(out.rq().unwrap()), Rd(out.rq().unwrap())
+            ; test Rq(reg.rq().unwrap()), Rq(reg.rq().unwrap())
+            ; setz Rb(out.rq().unwrap())
+        );
+
+        self.block_state.regs.release(reg);
+
+        self.push(ValueLocation::Reg(out));
+    }
+
+    /// Pops i32 predicate and branches to the specified label
+    /// if the predicate is equal to zero.
+    pub fn br_if_false(&mut self, label: Label, f: impl FnOnce(&mut Self)) {
+        let val = self.pop();
+
+        f(self);
+
+        let predicate = self.into_reg(I32, val);
+
+        dynasm!(self.asm
+            ; test Rd(predicate.rq().unwrap()), Rd(predicate.rq().unwrap())
+            ; jz =>label.0
+        );
+
+        self.block_state.regs.release(predicate);
+    }
+
+    /// Pops i32 predicate and branches to the specified label
+    /// if the predicate is not equal to zero.
+    pub fn br_if_true(&mut self, label: Label, f: impl FnOnce(&mut Self)) {
+        let val = self.pop();
+
+        f(self);
+
+        let predicate = self.into_reg(I32, val);
+
+        dynasm!(self.asm
+            ; test Rd(predicate.rq().unwrap()), Rd(predicate.rq().unwrap())
+            ; jnz =>label.0
+        );
+
+        self.block_state.regs.release(predicate);
+    }
+
+    /// Branch unconditionally to the specified label.
+    pub fn br(&mut self, label: Label) {
+        dynasm!(self.asm
+            ; jmp =>label.0
+        );
+    }
+
+    /// If `default` is `None` then the default is just continuing execution
+    pub fn br_table<I>(
+        &mut self,
+        targets: I,
+        default: Option<BrTarget<Label>>,
+        pass_args: impl FnOnce(&mut Self),
+    ) where
+        I: IntoIterator<Item = BrTarget<Label>>,
+        I::IntoIter: ExactSizeIterator,
+    {
+        let mut targets = targets.into_iter();
+        let count = targets.len();
+
+        let mut selector = self.pop();
+
+        pass_args(self);
+
+        if count == 0 {
+            if let Some(default) = default {
+                match default {
+                    BrTarget::Label(label) => self.br(label),
+                    BrTarget::Return => {
+                        dynasm!(self.asm
+                            ; ret
+                        );
+                    }
+                }
+            }
+        } else if let Some(imm) = selector.imm_i32() {
+            if let Some(target) = targets.nth(imm as _).or(default) {
+                match target {
+                    BrTarget::Label(label) => self.br(label),
+                    BrTarget::Return => {
+                        dynasm!(self.asm
+                            ; ret
+                        );
+                    }
+                }
+            }
+        } else {
+            let selector_reg = self.into_reg(GPRType::Rq, selector);
+            selector = ValueLocation::Reg(selector_reg);
+
+            // TODO: Jump table (wrestling with dynasm to implement it is too much work)
+            for (i, target) in targets.enumerate() {
+                let label = self.target_to_label(target);
+                dynasm!(self.asm
+                    ; cmp Rq(selector_reg.rq().unwrap()), i as i32
+                    ; je =>label.0
+                );
+            }
+
+            if let Some(def) = default {
+                match def {
+                    BrTarget::Label(label) => dynasm!(self.asm
+                        ; jmp =>label.0
+                    ),
+                    BrTarget::Return => dynasm!(self.asm
+                        ; ret
+                    ),
+                }
+            }
+        }
+
+        self.free_value(selector);
+    }
+
+    fn set_stack_depth_preserve_flags(&mut self, depth: StackDepth) {
+        if self.block_state.depth.0 < depth.0 {
+            // TODO: We need to preserve ZF on `br_if` so we use `push`/`pop` but that isn't
+            //       necessary on (for example) `br`.
+            for _ in 0..depth.0 - self.block_state.depth.0 {
+                dynasm!(self.asm
+                    ; push rax
+                );
+            }
+        } else if self.block_state.depth.0 > depth.0 {
+            let trash = self.block_state.regs.take(I64);
+            // TODO: We need to preserve ZF on `br_if` so we use `push`/`pop` but that isn't
+            //       necessary on (for example) `br`.
+            for _ in 0..self.block_state.depth.0 - depth.0 {
+                dynasm!(self.asm
+                    ; pop Rq(trash.rq().unwrap())
+                );
+            }
+        }
+
+        self.block_state.depth = depth;
+    }
+
+    fn set_stack_depth(&mut self, depth: StackDepth) {
+        if self.block_state.depth.0 != depth.0 {
+            let diff = depth.0 as i32 - self.block_state.depth.0 as i32;
+            if diff.abs() == 1 {
+                self.set_stack_depth_preserve_flags(depth);
+            } else {
+                dynasm!(self.asm
+                    ; add rsp, (self.block_state.depth.0 as i32 - depth.0 as i32) * WORD_SIZE as i32
+                );
+
+                self.block_state.depth = depth;
+            }
+        }
+    }
+
+    pub fn pass_block_args(&mut self, cc: &CallingConvention) {
+        let args = &cc.arguments;
+        for (remaining, &dst) in args
+            .iter()
+            .enumerate()
+            .rev()
+            .take(self.block_state.stack.len())
+        {
+            if let CCLoc::Reg(r) = dst {
+                if !self.block_state.regs.is_free(r)
+                    && *self.block_state.stack.last().unwrap() != ValueLocation::Reg(r)
+                {
+                    // TODO: This would be made simpler and more efficient with a proper SSE
+                    //       representation.
+                    self.save_regs(&[r], ..=remaining);
+                }
+
+                self.block_state.regs.mark_used(r);
+            }
+            self.pop_into(dst.into());
+        }
+
+        self.set_stack_depth(cc.stack_depth);
+    }
+
+    /// Puts all stack values into "real" locations so that they can i.e. be set to different
+    /// values on different iterations of a loop
+    pub fn serialize_args(&mut self, count: u32) -> CallingConvention {
+        let mut out = Vec::with_capacity(count as _);
+
+        for _ in 0..count {
+            let val = self.pop();
+            // TODO: We can use stack slots for values already on the stack but we
+            //       don't refcount stack slots right now
+            let loc = CCLoc::Reg(self.into_temp_reg(None, val));
+
+            out.push(loc);
+        }
+
+        out.reverse();
+
+        CallingConvention {
+            stack_depth: self.block_state.depth,
+            arguments: out,
+        }
+    }
+
+    fn immediate_to_reg(&mut self, reg: GPR, val: Value) {
+        match reg {
+            GPR::Rq(r) => {
+                let val = val.as_bytes();
+                if (val as u64) <= u32::max_value() as u64 {
+                    dynasm!(self.asm
+                        ; mov Rd(r), val as i32
+                    );
+                } else {
+                    dynasm!(self.asm
+                        ; mov Rq(r), QWORD val
+                    );
+                }
+            }
+            GPR::Rx(r) => {
+                let temp = self.block_state.regs.take(I64);
+                self.immediate_to_reg(temp, val);
+                dynasm!(self.asm
+                    ; movq Rx(r), Rq(temp.rq().unwrap())
+                );
+                self.block_state.regs.release(temp);
+            }
+        }
+    }
+
+    // The `&` and `&mut` aren't necessary (`ValueLocation` is copy) but it ensures that we don't get
+    // the arguments the wrong way around. In the future we want to have a `ReadLocation` and `WriteLocation`
+    // so we statically can't write to a literal so this will become a non-issue.
+    fn copy_value(&mut self, src: &ValueLocation, dst: &mut ValueLocation) {
+        match (*src, *dst) {
+            (ValueLocation::Stack(in_offset), ValueLocation::Stack(out_offset)) => {
+                let in_offset = self.adjusted_offset(in_offset);
+                let out_offset = self.adjusted_offset(out_offset);
+                if in_offset != out_offset {
+                    let gpr = self.block_state.regs.take(I64);
+                    dynasm!(self.asm
+                        ; mov Rq(gpr.rq().unwrap()), [rsp + in_offset]
+                        ; mov [rsp + out_offset], Rq(gpr.rq().unwrap())
+                    );
+                    self.block_state.regs.release(gpr);
+                }
+            }
+            // TODO: XMM registers
+            (ValueLocation::Reg(in_reg), ValueLocation::Stack(out_offset)) => {
+                let out_offset = self.adjusted_offset(out_offset);
+                match in_reg {
+                    GPR::Rq(in_reg) => {
+                        // We can always use `Rq` here for now because stack slots are in multiples of
+                        // 8 bytes
+                        dynasm!(self.asm
+                            ; mov [rsp + out_offset], Rq(in_reg)
+                        );
+                    }
+                    GPR::Rx(in_reg) => {
+                        // We can always use `movq` here for now because stack slots are in multiples of
+                        // 8 bytes
+                        dynasm!(self.asm
+                            ; movq [rsp + out_offset], Rx(in_reg)
+                        );
+                    }
+                }
+            }
+            (ValueLocation::Immediate(i), ValueLocation::Stack(out_offset)) => {
+                // TODO: Floats
+                let i = i.as_bytes();
+                let out_offset = self.adjusted_offset(out_offset);
+                if (i as u64) <= u32::max_value() as u64 {
+                    dynasm!(self.asm
+                        ; mov DWORD [rsp + out_offset], i as i32
+                    );
+                } else {
+                    let scratch = self.block_state.regs.take(I64);
+
+                    dynasm!(self.asm
+                        ; mov Rq(scratch.rq().unwrap()), QWORD i
+                        ; mov [rsp + out_offset], Rq(scratch.rq().unwrap())
+                    );
+
+                    self.block_state.regs.release(scratch);
+                }
+            }
+            (ValueLocation::Stack(in_offset), ValueLocation::Reg(out_reg)) => {
+                let in_offset = self.adjusted_offset(in_offset);
+                match out_reg {
+                    GPR::Rq(out_reg) => {
+                        // We can always use `Rq` here for now because stack slots are in multiples of
+                        // 8 bytes
+                        dynasm!(self.asm
+                            ; mov Rq(out_reg), [rsp + in_offset]
+                        );
+                    }
+                    GPR::Rx(out_reg) => {
+                        // We can always use `movq` here for now because stack slots are in multiples of
+                        // 8 bytes
+                        dynasm!(self.asm
+                            ; movq Rx(out_reg), [rsp + in_offset]
+                        );
+                    }
+                }
+            }
+            (ValueLocation::Reg(in_reg), ValueLocation::Reg(out_reg)) => {
+                if in_reg != out_reg {
+                    match (in_reg, out_reg) {
+                        (GPR::Rq(in_reg), GPR::Rq(out_reg)) => {
+                            dynasm!(self.asm
+                                ; mov Rq(out_reg), Rq(in_reg)
+                            );
+                        }
+                        (GPR::Rx(in_reg), GPR::Rq(out_reg)) => {
+                            dynasm!(self.asm
+                                ; movq Rq(out_reg), Rx(in_reg)
+                            );
+                        }
+                        (GPR::Rq(in_reg), GPR::Rx(out_reg)) => {
+                            dynasm!(self.asm
+                                ; movq Rx(out_reg), Rq(in_reg)
+                            );
+                        }
+                        (GPR::Rx(in_reg), GPR::Rx(out_reg)) => {
+                            dynasm!(self.asm
+                                ; movq Rx(out_reg), Rx(in_reg)
+                            );
+                        }
+                    }
+                }
+            }
+            (ValueLocation::Immediate(i), ValueLocation::Reg(out_reg)) => {
+                // TODO: Floats
+                self.immediate_to_reg(out_reg, i);
+            }
+            // TODO: Have separate `ReadLocation` and `WriteLocation`?
+            (_, ValueLocation::Immediate(_)) => panic!("Tried to copy to an immediate value!"),
+        }
+    }
+
+    /// Define the given label at the current position.
+    ///
+    /// Multiple labels can be defined at the same position. However, a label
+    /// can be defined only once.
+    pub fn define_label(&mut self, label: Label) {
+        self.asm.dynamic_label(label.0);
+    }
+
+    pub fn set_state(&mut self, state: VirtualCallingConvention) {
+        self.block_state.regs = Registers::new();
+        for elem in &state.stack {
+            if let ValueLocation::Reg(r) = elem {
+                self.block_state.regs.mark_used(*r);
+            }
+        }
+        self.block_state.stack = state.stack;
+        self.block_state.depth = state.depth;
+    }
+
+    pub fn apply_cc(&mut self, cc: &CallingConvention) {
+        let stack = cc.arguments.iter();
+
+        self.block_state.stack = Vec::with_capacity(stack.size_hint().0);
+        self.block_state.regs = Registers::new();
+
+        for &elem in stack {
+            if let CCLoc::Reg(r) = elem {
+                self.block_state.regs.mark_used(r);
+            }
+
+            self.block_state.stack.push(elem.into());
+        }
+
+        self.block_state.depth = cc.stack_depth;
+    }
+
+    load!(i32_load, Rd, "i32.load", I32);
+    load!(i64_load, Rq, "i64.load", I64);
+    store!(i32_store, Rd, DWORD, "i32.store", I32);
+    store!(i64_store, Rq, QWORD, "i64.store", I64);
+
+    fn push_physical(&mut self, value: ValueLocation) -> ValueLocation {
+        self.block_state.depth.reserve(1);
+        match value {
+            ValueLocation::Reg(gpr) => {
+                // TODO: Proper stack allocation scheme
+                dynasm!(self.asm
+                    ; push Rq(gpr.rq().unwrap())
+                );
+                self.block_state.regs.release(gpr);
+            }
+            ValueLocation::Stack(o) => {
+                let offset = self.adjusted_offset(o);
+                dynasm!(self.asm
+                    ; push QWORD [rsp + offset]
+                );
+            }
+            ValueLocation::Immediate(imm) => {
+                let gpr = self.block_state.regs.take(I64);
+                dynasm!(self.asm
+                    ; mov Rq(gpr.rq().unwrap()), QWORD imm.as_bytes()
+                    ; push Rq(gpr.rq().unwrap())
+                );
+                self.block_state.regs.release(gpr);
+            }
+        }
+        ValueLocation::Stack(-(self.block_state.depth.0 as i32))
+    }
+
+    fn push(&mut self, value: ValueLocation) {
+        self.block_state.stack.push(value);
+    }
+
+    fn pop(&mut self) -> ValueLocation {
+        self.block_state.stack.pop().expect("Stack is empty")
+    }
+
+    pub fn drop(&mut self, range: RangeInclusive<u32>) {
+        let mut repush = Vec::with_capacity(*range.start() as _);
+
+        for _ in 0..*range.start() {
+            repush.push(self.pop());
+        }
+
+        for _ in range {
+            let val = self.pop();
+            self.free_value(val);
+        }
+
+        for v in repush.into_iter().rev() {
+            self.push(v);
+        }
+    }
+
+    fn pop_into(&mut self, dst: ValueLocation) {
+        let val = self.pop();
+        self.copy_value(&val, &mut { dst });
+        self.free_value(val);
+    }
+
+    fn free_value(&mut self, val: ValueLocation) {
+        match val {
+            ValueLocation::Reg(r) => {
+                self.block_state.regs.release(r);
+            }
+            // TODO: Refcounted stack slots
+            _ => {}
+        }
+    }
+
+    /// Puts this value into a register so that it can be efficiently read
+    // TODO: We should allow choosing which reg type we want to allocate here (Rx/Rq)
+    fn into_reg(&mut self, ty: impl Into<Option<GPRType>>, val: ValueLocation) -> GPR {
+        match val {
+            ValueLocation::Reg(r) if ty.into().map(|t| t == r.type_()).unwrap_or(true) => r,
+            val => {
+                let scratch = self.block_state.regs.take(ty.into().unwrap_or(GPRType::Rq));
+
+                self.copy_value(&val, &mut ValueLocation::Reg(scratch));
+                self.free_value(val);
+
+                scratch
+            }
+        }
+    }
+
+    /// Puts this value into a temporary register so that operations
+    /// on that register don't write to a local.
+    fn into_temp_reg(&mut self, ty: impl Into<Option<GPRType>>, val: ValueLocation) -> GPR {
+        // If we have `None` as the type then it always matches (`.unwrap_or(true)`)
+        match val {
+            ValueLocation::Reg(r) => {
+                let ty = ty.into();
+                let type_matches = ty.map(|t| t == r.type_()).unwrap_or(true);
+
+                if self.block_state.regs.num_usages(r) <= 1 && type_matches {
+                    r
+                } else {
+                    let scratch = self.block_state.regs.take(ty.unwrap_or(GPRType::Rq));
+
+                    self.copy_value(&val, &mut ValueLocation::Reg(scratch));
+                    self.free_value(val);
+
+                    scratch
+                }
+            }
+            val => self.into_reg(ty, val),
+        }
+    }
+
+    pub fn f32_neg(&mut self) {
+        let val = self.pop();
+
+        let out = if let Some(i) = val.imm_f32() {
+            ValueLocation::Immediate(
+                wasmparser::Ieee32((-f32::from_bits(i.bits())).to_bits()).into(),
+            )
+        } else {
+            let reg = self.into_temp_reg(GPRType::Rx, val);
+            let const_label = self.neg_const_f32_label();
+
+            dynasm!(self.asm
+                ; xorps Rx(reg.rx().unwrap()), [=>const_label.0]
+            );
+
+            ValueLocation::Reg(reg)
+        };
+
+        self.push(out);
+    }
+
+    pub fn f64_neg(&mut self) {
+        let val = self.pop();
+
+        let out = if let Some(i) = val.imm_f64() {
+            ValueLocation::Immediate(
+                wasmparser::Ieee64((-f64::from_bits(i.bits())).to_bits()).into(),
+            )
+        } else {
+            let reg = self.into_temp_reg(GPRType::Rx, val);
+            let const_label = self.neg_const_f64_label();
+
+            dynasm!(self.asm
+                ; xorpd Rx(reg.rx().unwrap()), [=>const_label.0]
+            );
+
+            ValueLocation::Reg(reg)
+        };
+
+        self.push(out);
+    }
+
+    unop!(i32_clz, lzcnt, Rd, u32, u32::leading_zeros);
+    unop!(i64_clz, lzcnt, Rq, u64, |a: u64| a.leading_zeros() as u64);
+    unop!(i32_ctz, tzcnt, Rd, u32, u32::trailing_zeros);
+    unop!(i64_ctz, tzcnt, Rq, u64, |a: u64| a.trailing_zeros() as u64);
+    unop!(i32_popcnt, popcnt, Rd, u32, u32::count_ones);
+    unop!(i64_popcnt, popcnt, Rq, u64, |a: u64| a.count_ones() as u64);
+
+    // TODO: Use `lea` when the LHS operand isn't a temporary but both of the operands
+    //       are in registers.
+    commutative_binop_i32!(i32_add, add, i32::wrapping_add);
+    commutative_binop_i32!(i32_and, and, |a, b| a & b);
+    commutative_binop_i32!(i32_or, or, |a, b| a | b);
+    commutative_binop_i32!(i32_xor, xor, |a, b| a ^ b);
+    binop_i32!(i32_sub, sub, i32::wrapping_sub);
+
+    commutative_binop_i64!(i64_add, add, i64::wrapping_add);
+    commutative_binop_i64!(i64_and, and, |a, b| a & b);
+    commutative_binop_i64!(i64_or, or, |a, b| a | b);
+    commutative_binop_i64!(i64_xor, xor, |a, b| a ^ b);
+    binop_i64!(i64_sub, sub, i64::wrapping_sub);
+
+    commutative_binop_f32!(f32_add, addss, |a, b| a + b);
+    commutative_binop_f32!(f32_mul, mulss, |a, b| a * b);
+    binop_f32!(f32_sub, subss, |a, b| a - b);
+
+    commutative_binop_f64!(f64_add, addsd, |a, b| a + b);
+    commutative_binop_f64!(f64_mul, mulsd, |a, b| a * b);
+    binop_f64!(f64_sub, subsd, |a, b| a - b);
+
+    shift!(
+        i32_shl,
+        Rd,
+        shl,
+        |a, b| (a as i32).wrapping_shl(b as _),
+        I32
+    );
+    shift!(
+        i32_shr_s,
+        Rd,
+        sar,
+        |a, b| (a as i32).wrapping_shr(b as _),
+        I32
+    );
+    shift!(
+        i32_shr_u,
+        Rd,
+        shr,
+        |a, b| (a as u32).wrapping_shr(b as _),
+        I32
+    );
+    shift!(
+        i32_rotl,
+        Rd,
+        rol,
+        |a, b| (a as u32).rotate_left(b as _),
+        I32
+    );
+    shift!(
+        i32_rotr,
+        Rd,
+        ror,
+        |a, b| (a as u32).rotate_right(b as _),
+        I32
+    );
+
+    shift!(
+        i64_shl,
+        Rq,
+        shl,
+        |a, b| (a as i64).wrapping_shl(b as _),
+        I64
+    );
+    shift!(
+        i64_shr_s,
+        Rq,
+        sar,
+        |a, b| (a as i64).wrapping_shr(b as _),
+        I64
+    );
+    shift!(
+        i64_shr_u,
+        Rq,
+        shr,
+        |a, b| (a as u64).wrapping_shr(b as _),
+        I64
+    );
+    shift!(
+        i64_rotl,
+        Rq,
+        rol,
+        |a, b| (a as u64).rotate_left(b as _),
+        I64
+    );
+    shift!(
+        i64_rotr,
+        Rq,
+        ror,
+        |a, b| (a as u64).rotate_right(b as _),
+        I64
+    );
+
+    /// Returned divisor is guaranteed not to be `RAX`
+    // TODO: With a proper SSE-like "Value" system we could do this way better (we wouldn't have
+    //       to move `RAX` back afterwards).
+    fn i32_full_div(
+        &mut self,
+        divisor: ValueLocation,
+        quotient: ValueLocation,
+        do_div: impl FnOnce(&mut Self, ValueLocation),
+    ) -> (ValueLocation, ValueLocation, Option<GPR>) {
+        let divisor = if ValueLocation::Reg(RAX) == divisor {
+            let new_reg = self.block_state.regs.take(I32);
+            self.copy_value(&divisor, &mut ValueLocation::Reg(new_reg));
+            self.block_state.regs.release(RAX);
+            ValueLocation::Reg(new_reg)
+        } else if let ValueLocation::Stack(_) = divisor {
+            divisor
+        } else {
+            ValueLocation::Reg(self.into_temp_reg(I32, divisor))
+        };
+
+        self.free_value(quotient);
+        let should_save_rax = if self.block_state.regs.is_free(RAX) {
+            false
+        } else {
+            true
+        };
+
+        if let ValueLocation::Reg(r) = quotient {
+            self.block_state.regs.mark_used(r);
+        }
+
+        let saved_rax = if should_save_rax {
+            let new_reg = self.block_state.regs.take(I32);
+            dynasm!(self.asm
+                ; mov Rq(new_reg.rq().unwrap()), rax
+            );
+            Some(new_reg)
+        } else {
+            None
+        };
+
+        do_div(self, divisor);
+
+        (divisor, ValueLocation::Reg(RAX), saved_rax)
+    }
+
+    fn i32_full_div_u(
+        &mut self,
+        divisor: ValueLocation,
+        quotient: ValueLocation,
+    ) -> (ValueLocation, ValueLocation, Option<GPR>) {
+        self.i32_full_div(divisor, quotient, |this, divisor| match divisor {
+            ValueLocation::Stack(offset) => {
+                let offset = this.adjusted_offset(offset);
+                dynasm!(this.asm
+                    ; div [rsp + offset]
+                );
+            }
+            ValueLocation::Reg(r) => {
+                dynasm!(this.asm
+                    ; div Rq(r.rq().unwrap())
+                );
+            }
+            ValueLocation::Immediate(_) => unreachable!(),
+        })
+    }
+
+    fn i32_full_div_s(
+        &mut self,
+        divisor: ValueLocation,
+        quotient: ValueLocation,
+    ) -> (ValueLocation, ValueLocation, Option<GPR>) {
+        self.i32_full_div(divisor, quotient, |this, divisor| match divisor {
+            ValueLocation::Stack(offset) => {
+                let offset = this.adjusted_offset(offset);
+                dynasm!(this.asm
+                    ; idiv [rsp + offset]
+                );
+            }
+            ValueLocation::Reg(r) => {
+                dynasm!(this.asm
+                    ; idiv Rq(r.rq().unwrap())
+                );
+            }
+            ValueLocation::Immediate(_) => unreachable!(),
+        })
+    }
+
+    // TODO: Fast div using mul for constant divisor? It looks like LLVM doesn't do that for us when
+    //       emitting Wasm.
+    pub fn i32_div_u(&mut self) {
+        let divisor = self.pop();
+        let quotient = self.pop();
+
+        if let (Some(quotient), Some(divisor)) = (quotient.imm_i32(), divisor.imm_i32()) {
+            if divisor == 0 {
+                self.trap();
+                self.push(ValueLocation::Immediate(0u32.into()));
+            } else {
+                self.push(ValueLocation::Immediate(
+                    u32::wrapping_div(quotient as _, divisor as _).into(),
+                ));
+            }
+
+            return;
+        }
+
+        let (div, rem, saved_rax) = self.i32_full_div_u(divisor, quotient);
+
+        self.free_value(rem);
+
+        if let Some(saved) = saved_rax {
+            self.copy_value(&ValueLocation::Reg(saved), &mut ValueLocation::Reg(RAX));
+            self.block_state.regs.release(saved);
+            self.block_state.regs.mark_used(RAX);
+        }
+
+        self.push(div);
+    }
+
+    pub fn i32_rem_u(&mut self) {
+        let divisor = self.pop();
+        let quotient = self.pop();
+
+        if let (Some(quotient), Some(divisor)) = (quotient.imm_i32(), divisor.imm_i32()) {
+            if divisor == 0 {
+                self.trap();
+                self.push(ValueLocation::Immediate(0u32.into()));
+            } else {
+                self.push(ValueLocation::Immediate(
+                    (quotient as u32 % divisor as u32).into(),
+                ));
+            }
+            return;
+        }
+
+        let (div, rem, saved_rax) = self.i32_full_div_u(divisor, quotient);
+
+        self.free_value(div);
+
+        let rem = if let Some(saved) = saved_rax {
+            let new_gpr = self.block_state.regs.take(I32);
+            self.copy_value(&ValueLocation::Reg(RAX), &mut ValueLocation::Reg(new_gpr));
+            self.copy_value(&ValueLocation::Reg(saved), &mut ValueLocation::Reg(RAX));
+            self.block_state.regs.release(saved);
+            ValueLocation::Reg(new_gpr)
+        } else {
+            rem
+        };
+
+        self.push(rem);
+    }
+
+    pub fn i32_rem_s(&mut self) {
+        let divisor = self.pop();
+        let quotient = self.pop();
+
+        if let (Some(quotient), Some(divisor)) = (quotient.imm_i32(), divisor.imm_i32()) {
+            if divisor == 0 {
+                self.trap();
+                self.push(ValueLocation::Immediate(0u32.into()));
+            } else {
+                self.push(ValueLocation::Immediate((quotient % divisor).into()));
+            }
+            return;
+        }
+
+        let (div, rem, saved_rax) = self.i32_full_div_s(divisor, quotient);
+
+        self.free_value(div);
+
+        let rem = if let Some(saved) = saved_rax {
+            let new_gpr = self.block_state.regs.take(I32);
+            self.copy_value(&ValueLocation::Reg(RAX), &mut ValueLocation::Reg(new_gpr));
+            self.copy_value(&ValueLocation::Reg(saved), &mut ValueLocation::Reg(RAX));
+            self.block_state.regs.release(saved);
+            ValueLocation::Reg(new_gpr)
+        } else {
+            rem
+        };
+
+        self.push(rem);
+    }
+
+    // TODO: Fast div using mul for constant divisor? It looks like LLVM doesn't do that for us when
+    //       emitting Wasm.
+    pub fn i32_div_s(&mut self) {
+        let divisor = self.pop();
+        let quotient = self.pop();
+
+        if let (Some(quotient), Some(divisor)) = (quotient.imm_i32(), divisor.imm_i32()) {
+            if divisor == 0 {
+                self.trap();
+                self.push(ValueLocation::Immediate(0u32.into()));
+            } else {
+                self.push(ValueLocation::Immediate(
+                    i32::wrapping_div(quotient, divisor).into(),
+                ));
+            }
+
+            return;
+        }
+
+        let (div, rem, saved_rax) = self.i32_full_div_s(divisor, quotient);
+
+        self.free_value(rem);
+
+        if let Some(saved) = saved_rax {
+            self.copy_value(&ValueLocation::Reg(saved), &mut ValueLocation::Reg(RAX));
+            self.block_state.regs.release(saved);
+            self.block_state.regs.mark_used(RAX);
+        }
+
+        self.push(div);
+    }
+
+    // `i32_mul` needs to be separate because the immediate form of the instruction
+    // has a different syntax to the immediate form of the other instructions.
+    pub fn i32_mul(&mut self) {
+        let op0 = self.pop();
+        let op1 = self.pop();
+
+        if let Some(i1) = op1.immediate() {
+            if let Some(i0) = op0.immediate() {
+                self.push(ValueLocation::Immediate(
+                    i32::wrapping_mul(i1.as_i32().unwrap(), i0.as_i32().unwrap()).into(),
+                ));
+                return;
+            }
+        }
+
+        let (op1, op0) = match op1 {
+            ValueLocation::Reg(_) => (self.into_temp_reg(I32, op1), op0),
+            _ => {
+                if op0.immediate().is_some() {
+                    (self.into_temp_reg(I32, op1), op0)
+                } else {
+                    (self.into_temp_reg(I32, op0), op1)
+                }
+            }
+        };
+
+        match op0 {
+            ValueLocation::Reg(reg) => {
+                dynasm!(self.asm
+                    ; imul Rd(op1.rq().unwrap()), Rd(reg.rq().unwrap())
+                );
+            }
+            ValueLocation::Stack(offset) => {
+                let offset = self.adjusted_offset(offset);
+                dynasm!(self.asm
+                    ; imul Rd(op1.rq().unwrap()), [rsp + offset]
+                );
+            }
+            ValueLocation::Immediate(i) => {
+                dynasm!(self.asm
+                    ; imul Rd(op1.rq().unwrap()), Rd(op1.rq().unwrap()), i.as_i32().unwrap()
+                );
+            }
+        }
+
+        self.push(ValueLocation::Reg(op1));
+        self.free_value(op0);
+    }
+
+    // `i64_mul` needs to be separate because the immediate form of the instruction
+    // has a different syntax to the immediate form of the other instructions.
+    pub fn i64_mul(&mut self) {
+        let op0 = self.pop();
+        let op1 = self.pop();
+
+        if let Some(i1) = op1.imm_i64() {
+            if let Some(i0) = op0.imm_i64() {
+                self.block_state
+                    .stack
+                    .push(ValueLocation::Immediate(i64::wrapping_mul(i1, i0).into()));
+                return;
+            }
+        }
+
+        let (op1, op0) = match op1 {
+            ValueLocation::Reg(_) => (self.into_temp_reg(I64, op1), op0),
+            _ => {
+                if op0.immediate().is_some() {
+                    (self.into_temp_reg(I64, op1), op0)
+                } else {
+                    (self.into_temp_reg(I64, op0), op1)
+                }
+            }
+        };
+
+        match op0 {
+            ValueLocation::Reg(reg) => {
+                dynasm!(self.asm
+                    ; imul Rq(op1.rq().unwrap()), Rq(reg.rq().unwrap())
+                );
+            }
+            ValueLocation::Stack(offset) => {
+                let offset = self.adjusted_offset(offset);
+                dynasm!(self.asm
+                    ; imul Rq(op1.rq().unwrap()), [rsp + offset]
+                );
+            }
+            ValueLocation::Immediate(i) => {
+                let i = i.as_int().unwrap();
+                if let Some(i) = i.try_into() {
+                    dynasm!(self.asm
+                        ; imul Rq(op1.rq().unwrap()), Rq(op1.rq().unwrap()), i
+                    );
+                } else {
+                    unimplemented!(concat!(
+                        "Unsupported `imul` with large 64-bit immediate operand"
+                    ));
+                }
+            }
+        }
+
+        self.push(ValueLocation::Reg(op1));
+        self.free_value(op0);
+    }
+
+    pub fn select(&mut self) {
+        let cond = self.pop();
+        let else_ = self.pop();
+        let then = self.pop();
+
+        match cond {
+            ValueLocation::Immediate(i) => {
+                if i.as_i32().unwrap() == 0 {
+                    self.push(else_);
+                } else {
+                    self.push(then);
+                }
+
+                return;
+            }
+            other => {
+                let reg = self.into_reg(I32, other);
+
+                dynasm!(self.asm
+                    ; test Rd(reg.rq().unwrap()), Rd(reg.rq().unwrap())
+                );
+
+                self.block_state.regs.release(reg);
+            }
+        }
+
+        let out_gpr = self.block_state.regs.take(GPRType::Rq);
+
+        // TODO: Can do this better for variables on stack
+        macro_rules! cmov_helper {
+            ($instr:ident, $val:expr) => {
+                match $val {
+                    ValueLocation::Stack(offset) => {
+                        let offset = self.adjusted_offset(offset);
+                        dynasm!(self.asm
+                            ; $instr Rq(out_gpr.rq().unwrap()), [rsp + offset]
+                        );
+                    }
+                    other => {
+                        let scratch = self.into_reg(GPRType::Rq, other);
+                        dynasm!(self.asm
+                            ; $instr Rq(out_gpr.rq().unwrap()), Rq(scratch.rq().unwrap())
+                        );
+                        self.block_state.regs.release(scratch);
+                    }
+                }
+            }
+        }
+
+        cmov_helper!(cmovz, else_);
+        cmov_helper!(cmovnz, then);
+
+        self.push(ValueLocation::Reg(out_gpr));
+    }
+
+    pub fn pick(&mut self, depth: u32) {
+        let idx = self.block_state.stack.len() - 1 - depth as usize;
+        let v = self.block_state.stack[idx];
+
+        match v {
+            ValueLocation::Reg(r) => {
+                self.block_state.regs.mark_used(r);
+            }
+            _ => {}
+        }
+
+        self.block_state.stack.push(v);
+    }
+
+    pub fn const_(&mut self, imm: Value) {
+        self.push(ValueLocation::Immediate(imm));
+    }
+
+    // TODO: Use `ArrayVec`?
+    // TODO: This inefficiently duplicates registers but it's not really possible
+    //       to double up stack space right now.
+    /// Saves volatile (i.e. caller-saved) registers before a function call, if they are used.
+    fn save_volatile(&mut self, bounds: impl std::ops::RangeBounds<usize>) {
+        self.save_regs(SCRATCH_REGS, bounds);
+    }
+
+    fn save_regs<I>(&mut self, regs: &I, bounds: impl std::ops::RangeBounds<usize>)
+    where
+        for<'a> &'a I: IntoIterator<Item = &'a GPR>,
+        I: ?Sized,
+    {
+        use std::ops::Bound::*;
+
+        let mut stack = mem::replace(&mut self.block_state.stack, vec![]);
+        let (start, end) = (
+            match bounds.end_bound() {
+                Unbounded => 0,
+                Included(v) => stack.len() - 1 - v,
+                Excluded(v) => stack.len() - v,
+            },
+            match bounds.start_bound() {
+                Unbounded => stack.len(),
+                Included(v) => stack.len() - v,
+                Excluded(v) => stack.len() - 1 - v,
+            },
+        );
+        for val in stack[start..end].iter_mut() {
+            if let ValueLocation::Reg(vreg) = *val {
+                if regs.into_iter().any(|r| *r == vreg) {
+                    *val = self.push_physical(*val);
+                }
+            }
+        }
+
+        mem::replace(&mut self.block_state.stack, stack);
+    }
+
+    /// Write the arguments to the callee to the registers and the stack using the SystemV
+    /// calling convention.
+    fn pass_outgoing_args(&mut self, out_locs: &[CCLoc]) {
+        self.save_volatile(out_locs.len()..);
+
+        // TODO: Do alignment here
+        let total_stack_space = out_locs
+            .iter()
+            .flat_map(|&l| {
+                if let CCLoc::Stack(offset) = l {
+                    if offset > 0 {
+                        Some(offset as u32)
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            })
+            .max()
+            .unwrap_or(0);
+        let depth = self.block_state.depth.0 + total_stack_space;
+
+        let mut pending = Vec::<(ValueLocation, ValueLocation)>::new();
+
+        for &loc in out_locs.iter().rev() {
+            let val = self.pop();
+
+            match loc {
+                CCLoc::Stack(offset) => {
+                    let offset = self.adjusted_offset(offset as i32 - depth as i32);
+
+                    if offset == -(WORD_SIZE as i32) {
+                        self.push_physical(val);
+                    } else {
+                        let gpr = self.into_reg(GPRType::Rq, val);
+                        dynasm!(self.asm
+                            ; mov [rsp + offset], Rq(gpr.rq().unwrap())
+                        );
+                        self.block_state.regs.release(gpr);
+                    }
+                }
+                CCLoc::Reg(r) => {
+                    if val == ValueLocation::Reg(r) {
+                        self.free_value(val);
+                    } else if self.block_state.regs.is_free(r) {
+                        self.copy_value(&val, &mut loc.into());
+                        self.free_value(val);
+                    } else {
+                        pending.push((val, loc.into()));
+                    }
+                }
+            }
+        }
+
+        let mut try_count = 10;
+        while !pending.is_empty() {
+            try_count -= 1;
+
+            if try_count == 0 {
+                unimplemented!("We can't handle cycles in the register allocation right now");
+            }
+
+            for (src, dst) in mem::replace(&mut pending, vec![]) {
+                if let ValueLocation::Reg(r) = dst {
+                    if !self.block_state.regs.is_free(r) {
+                        pending.push((src, dst));
+                        continue;
+                    }
+                }
+                self.copy_value(&src, &mut { dst });
+                self.free_value(src);
+            }
+        }
+
+        self.set_stack_depth(StackDepth(depth));
+    }
+
+    // TODO: Multiple returns
+    fn push_function_return(&mut self, arity: u32) {
+        if arity == 0 {
+            return;
+        }
+        debug_assert_eq!(arity, 1);
+        self.block_state.regs.mark_used(RAX);
+        self.push(ValueLocation::Reg(RAX));
+    }
+
+    // TODO: Do return types properly
+    pub fn call_indirect(
+        &mut self,
+        signature_hash: u32,
+        arg_types: impl IntoIterator<Item = SignlessType>,
+        return_arity: u32,
+    ) {
+        debug_assert!(
+            return_arity == 0 || return_arity == 1,
+            "We don't support multiple return yet"
+        );
+
+        let locs = arg_locs(arg_types);
+
+        for &loc in &locs {
+            if let CCLoc::Reg(r) = loc {
+                self.block_state.regs.mark_used(r);
+            }
+        }
+
+        let callee = self.pop();
+        let callee = self.into_temp_reg(I32, callee);
+        let temp0 = self.block_state.regs.take(I64);
+
+        for &loc in &locs {
+            if let CCLoc::Reg(r) = loc {
+                self.block_state.regs.release(r);
+            }
+        }
+
+        self.pass_outgoing_args(&locs);
+
+        let fail = self.trap_label().0;
+
+        // TODO: Consider generating a single trap function and jumping to that instead.
+        dynasm!(self.asm
+            ; cmp Rd(callee.rq().unwrap()), [Rq(VMCTX) + self.module_context.offset_of_funcs_len() as i32]
+            ; jae =>fail
+            ; imul Rd(callee.rq().unwrap()), Rd(callee.rq().unwrap()), mem::size_of::<RuntimeFunc>() as i32
+            ; mov Rq(temp0.rq().unwrap()), [Rq(VMCTX) + self.module_context.offset_of_funcs_ptr() as i32]
+            ; cmp DWORD [
+                Rq(temp0.rq().unwrap()) +
+                    Rq(callee.rq().unwrap()) +
+                    RuntimeFunc::offset_of_sig_hash() as i32
+            ], signature_hash as i32
+            ; jne =>fail
+        );
+
+        dynasm!(self.asm
+            ; call QWORD [
+                Rq(temp0.rq().unwrap()) +
+                    Rq(callee.rq().unwrap()) +
+                    RuntimeFunc::offset_of_func_start() as i32
+            ]
+        );
+
+        self.block_state.regs.release(temp0);
+        self.block_state.regs.release(callee);
+
+        self.push_function_return(return_arity);
+    }
+
+    pub fn swap(&mut self, depth: u32) {
+        let last = self.block_state.stack.len() - 1;
+        self.block_state.stack.swap(last, last - depth as usize);
+    }
+
+    /// Call a function with the given index
+    pub fn call_direct(
+        &mut self,
+        index: u32,
+        arg_types: impl IntoIterator<Item = SignlessType>,
+        return_arity: u32,
+    ) {
+        debug_assert!(
+            return_arity == 0 || return_arity == 1,
+            "We don't support multiple return yet"
+        );
+
+        self.pass_outgoing_args(&arg_locs(arg_types));
+
+        let label = &self.func_starts[index as usize].1;
+        dynasm!(self.asm
+            ; call =>*label
+        );
+
+        self.push_function_return(return_arity);
+    }
+
+    // TODO: Reserve space to store RBX, RBP, and R12..R15 so we can use them
+    //       as scratch registers
+    // TODO: Allow use of unused argument registers as scratch registers.
+    /// Writes the function prologue and stores the arguments as locals
+    pub fn start_function(&mut self, params: impl IntoIterator<Item = SignlessType>) {
+        let locs = Vec::from_iter(arg_locs(params));
+        self.apply_cc(&CallingConvention::function_start(locs));
+    }
+
+    pub fn ret(&mut self) {
+        dynasm!(self.asm
+            ; ret
+        );
+    }
+
+    fn align(&mut self, align_to: u32) {
+        dynasm!(self.asm
+            ; .align align_to as usize
+        );
+    }
+
+    /// Writes the function epilogue (right now all this does is add the trap label that the
+    /// conditional traps in `call_indirect` use)
+    pub fn epilogue(&mut self) {
+        // TODO: We don't want to redefine this label if we're sharing it between functions
+        if let Some(l) = self.labels.trap {
+            self.define_label(l);
+            dynasm!(self.asm
+                ; ud2
+            );
+        }
+
+        if let Some(l) = self.labels.ret {
+            self.define_label(l);
+            dynasm!(self.asm
+                ; ret
+            );
+        }
+
+        if let Some(l) = self.labels.neg_const_f32 {
+            self.align(16);
+            self.define_label(l);
+            dynasm!(self.asm
+                ; .dword -2147483648
+                ; .dword 0
+                ; .dword 0
+                ; .dword 0
+            );
+        }
+
+        if let Some(l) = self.labels.neg_const_f64 {
+            self.align(16);
+            self.define_label(l);
+            dynasm!(self.asm
+                ; .dword 0
+                ; .dword -2147483648
+                ; .dword 0
+                ; .dword 0
+            );
+        }
+    }
+
+    pub fn trap(&mut self) {
+        dynasm!(self.asm
+            ; ud2
+        );
+    }
+
+    fn target_to_label(&mut self, target: BrTarget<Label>) -> Label {
+        match target {
+            BrTarget::Label(label) => label,
+            BrTarget::Return => self.ret_label(),
+        }
+    }
+
+    #[must_use]
+    fn trap_label(&mut self) -> Label {
+        if let Some(l) = self.labels.trap {
+            return l;
+        }
+
+        let label = self.create_label();
+        self.labels.trap = Some(label);
+        label
+    }
+
+    #[must_use]
+    fn ret_label(&mut self) -> Label {
+        if let Some(l) = self.labels.ret {
+            return l;
+        }
+
+        let label = self.create_label();
+        self.labels.ret = Some(label);
+        label
+    }
+
+    #[must_use]
+    fn neg_const_f32_label(&mut self) -> Label {
+        if let Some(l) = self.labels.neg_const_f32 {
+            return l;
+        }
+
+        let label = self.create_label();
+        self.labels.neg_const_f32 = Some(label);
+        label
+    }
+
+    #[must_use]
+    fn neg_const_f64_label(&mut self) -> Label {
+        if let Some(l) = self.labels.neg_const_f64 {
+            return l;
+        }
+
+        let label = self.create_label();
+        self.labels.neg_const_f64 = Some(label);
+        label
+    }
+}
+
diff --git a/src/disassemble.rs b/src/disassemble.rs
index d3bb9cafe5..e846d12341 100644
--- a/src/disassemble.rs
+++ b/src/disassemble.rs
@@ -20,7 +20,7 @@ pub fn disassemble(mem: &[u8]) -> Result<(), Error> {
         for b in i.bytes() {
             write!(&mut bytes_str, "{:02x} ", b).unwrap();
         }
-        write!(&mut line, "{:21}\t", bytes_str).unwrap();
+        write!(&mut line, "{:24}\t", bytes_str).unwrap();
 
         if let Some(s) = i.mnemonic() {
             write!(&mut line, "{}\t", s).unwrap();
diff --git a/src/error.rs b/src/error.rs
index 5f2ac6492e..c7b1fe46e8 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -20,6 +20,12 @@ impl From<BinaryReaderError> for Error {
     }
 }
 
+impl From<!> for Error {
+    fn from(other: !) -> Self {
+        other
+    }
+}
+
 impl From<capstone::Error> for Error {
     fn from(e: capstone::Error) -> Self {
         Error::Disassembler(e.to_string())
diff --git a/src/function_body.rs b/src/function_body.rs
index bdd000d7ca..52efc81df1 100644
--- a/src/function_body.rs
+++ b/src/function_body.rs
@@ -1,240 +1,487 @@
-use backend::*;
-use error::Error;
-use module::TranslationContext;
-use wasmparser::{FunctionBody, Operator, Type};
+use crate::backend::*;
+use crate::error::Error;
+use crate::microwasm::*;
+use crate::module::{quickhash, ModuleContext, SigType, Signature};
+use either::{Either, Left, Right};
+use multi_mut::HashMapMultiMut;
+use std::{collections::HashMap, convert::TryInto, hash::Hash};
 
-// TODO: Use own declared `Type` enum.
-
-/// Type of a control frame.
-#[derive(Debug, Copy, Clone, PartialEq)]
-enum ControlFrameKind {
-    /// A regular block frame.
-    ///
-    /// Can be used for an implicit function block.
-    Block { end_label: Label },
-    /// Loop frame (branching to the beginning of block).
-    #[allow(unused)]
-    Loop { header: Label },
-    /// True-subblock of if expression.
-    IfTrue {
-        /// If jump happens inside the if-true block then control will
-        /// land on this label.
-        end_label: Label,
-
-        /// If the condition of the `if` statement is unsatisfied, control
-        /// will land on this label. This label might point to `else` block if it
-        /// exists. Otherwise it equal to `end_label`.
-        if_not: Label,
-    },
-    /// False-subblock of if expression.
-    IfFalse { end_label: Label },
+#[derive(Debug)]
+struct Block {
+    label: BrTarget<Label>,
+    calling_convention: Option<Either<CallingConvention, VirtualCallingConvention>>,
+    params: u32,
+    // TODO: Is there a cleaner way to do this? `has_backwards_callers` should always be set if `is_next`
+    //       is false, so we should probably use an `enum` here.
+    is_next: bool,
+    num_callers: Option<u32>,
+    actual_num_callers: u32,
+    has_backwards_callers: bool,
 }
 
-impl ControlFrameKind {
-    /// Returns a label which should be used as a branch destination.
-    fn br_destination(&self) -> Label {
-        match *self {
-            ControlFrameKind::Block { end_label } => end_label,
-            ControlFrameKind::Loop { header } => header,
-            ControlFrameKind::IfTrue { end_label, .. } => end_label,
-            ControlFrameKind::IfFalse { end_label } => end_label,
-        }
-    }
-
-    /// Returns `true` if this block of a loop kind.
-    fn is_loop(&self) -> bool {
-        match *self {
-            ControlFrameKind::Loop { .. } => true,
-            _ => false,
-        }
+impl Block {
+    fn should_serialize_args(&self) -> bool {
+        self.calling_convention.is_none()
+            && (self.num_callers != Some(1) || self.has_backwards_callers)
     }
 }
 
-struct ControlFrame {
-    kind: ControlFrameKind,
-    /// Boolean which signals whether value stack became polymorphic. Value stack starts in non-polymorphic state and
-    /// becomes polymorphic only after an instruction that never passes control further is executed,
-    /// i.e. `unreachable`, `br` (but not `br_if`!), etc.
-    stack_polymorphic: bool,
-    /// Relative stack depth at the beginning of the frame.
-    stack_depth: StackDepth,
-    ty: Type,
-}
+const DISASSEMBLE: bool = false;
 
-impl ControlFrame {
-    pub fn new(kind: ControlFrameKind, stack_depth: StackDepth, ty: Type) -> ControlFrame {
-        ControlFrame {
-            kind,
-            stack_depth,
-            ty,
-            stack_polymorphic: false,
-        }
-    }
-
-    pub fn outgoing_stack_depth(&self) -> StackDepth {
-        let mut outgoing_stack_depth = self.stack_depth;
-        if self.ty != Type::EmptyBlockType {
-            // If there a return value then reserve expected outgoing stack depth value
-            // to account for the result value.
-            outgoing_stack_depth.reserve(1);
-        }
-        outgoing_stack_depth
-    }
-
-    /// Marks this control frame as reached stack-polymorphic state.
-    pub fn mark_stack_polymorphic(&mut self) {
-        self.stack_polymorphic = true;
-    }
-}
-
-pub fn translate(
-    session: &mut CodeGenSession,
-    translation_ctx: &TranslationContext,
+pub fn translate_wasm<M: ModuleContext>(
+    session: &mut CodeGenSession<M>,
     func_idx: u32,
-    body: &FunctionBody,
-) -> Result<(), Error> {
-    let locals = body.get_locals_reader()?;
+    body: &wasmparser::FunctionBody,
+) -> Result<(), Error>
+where
+    for<'any> &'any M::Signature: Into<OpSig>,
+{
+    let ty = session.module_context.func_type(func_idx);
 
-    let func_type = translation_ctx.func_type(func_idx);
-    let arg_count = func_type.params.len() as u32;
-    let return_ty = if func_type.returns.len() > 0 {
-        func_type.returns[0]
-    } else {
-        Type::EmptyBlockType
-    };
+    if DISASSEMBLE {
+        let mut microwasm = vec![];
 
-    let mut framesize = arg_count;
-    for local in locals {
-        let (count, _ty) = local?;
-        framesize += count;
+        let microwasm_conv = MicrowasmConv::new(
+            session.module_context,
+            ty.params().iter().map(SigType::to_microwasm_type),
+            ty.returns().iter().map(SigType::to_microwasm_type),
+            body,
+        );
+
+        for ops in microwasm_conv {
+            microwasm.extend(ops?);
+        }
+
+        println!("{}", crate::microwasm::dis(func_idx, &microwasm));
     }
 
-    let mut ctx = session.new_context(func_idx);
-    let operators = body.get_operators_reader()?;
+    let microwasm_conv = MicrowasmConv::new(
+        session.module_context,
+        ty.params().iter().map(SigType::to_microwasm_type),
+        ty.returns().iter().map(SigType::to_microwasm_type),
+        body,
+    );
 
-    prologue(&mut ctx, framesize);
+    translate(
+        session,
+        func_idx,
+        microwasm_conv.flat_map(|i| i.expect("TODO: Make this not panic")),
+    )
+}
 
-    for arg_pos in 0..arg_count {
-        copy_incoming_arg(&mut ctx, arg_pos);
-    }
+pub fn translate<M: ModuleContext, I, L>(
+    session: &mut CodeGenSession<M>,
+    func_idx: u32,
+    body: I,
+) -> Result<(), Error>
+where
+    I: IntoIterator<Item = Operator<L>>,
+    L: Hash + Clone + Eq,
+    Operator<L>: std::fmt::Display,
+{
+    let func_type = session.module_context.defined_func_type(func_idx);
+    let mut body = body.into_iter().peekable();
 
-    let mut control_frames = Vec::new();
+    let ctx = &mut session.new_context(func_idx);
 
-    // Upon entering the function implicit frame for function body is pushed. It has the same
-    // result type as the function itself. Branching to it is equivalent to returning from the function.
-    let epilogue_label = create_label(&mut ctx);
-    control_frames.push(ControlFrame::new(
-        ControlFrameKind::Block {
-            end_label: epilogue_label,
+    let params = func_type
+        .params()
+        .iter()
+        .map(|t| t.to_microwasm_type())
+        .collect::<Vec<_>>();
+
+    ctx.start_function(params.iter().cloned());
+
+    let mut blocks = HashMap::<BrTarget<L>, Block>::new();
+
+    let num_returns = func_type.returns().len();
+
+    blocks.insert(
+        BrTarget::Return,
+        Block {
+            label: BrTarget::Return,
+            params: num_returns as u32,
+            // TODO: This only works for integers
+            //
+            calling_convention: Some(Left(CallingConvention::function_start(ret_locs(
+                func_type.returns().iter().map(|t| t.to_microwasm_type()),
+            )))),
+            is_next: false,
+            has_backwards_callers: false,
+            actual_num_callers: 0,
+            num_callers: None,
         },
-        current_stack_depth(&ctx),
-        return_ty,
-    ));
+    );
 
-    for op in operators {
-        match op? {
+    loop {
+        let op = if let Some(op) = body.next() {
+            op
+        } else {
+            break;
+        };
+
+        if let Some(Operator::Label(label)) = body.peek() {
+            let block = blocks
+                .get_mut(&BrTarget::Label(label.clone()))
+                .expect("Block definition should be before label definition");
+            block.is_next = true;
+        }
+
+        match op {
             Operator::Unreachable => {
-                control_frames
-                    .last_mut()
-                    .expect("control stack is never empty")
-                    .mark_stack_polymorphic();
-                trap(&mut ctx);
+                ctx.trap();
             }
-            Operator::If { ty } => {
-                let end_label = create_label(&mut ctx);
-                let if_not = create_label(&mut ctx);
+            Operator::Label(label) => {
+                use std::collections::hash_map::Entry;
 
-                pop_and_breq(&mut ctx, if_not);
+                if let Entry::Occupied(mut entry) = blocks.entry(BrTarget::Label(label)) {
+                    let has_backwards_callers = {
+                        let block = entry.get_mut();
 
-                control_frames.push(ControlFrame::new(
-                    ControlFrameKind::IfTrue { end_label, if_not },
-                    current_stack_depth(&ctx),
-                    ty,
-                ));
+                        // TODO: Is it possible with arbitrary CFGs that a block will have _only_ backwards callers?
+                        //       Certainly for Microwasm generated from Wasm that is currently impossible.
+                        if block.actual_num_callers == 0 {
+                            loop {
+                                let done = match body.peek() {
+                                    Some(Operator::Label(_)) | None => true,
+                                    Some(_) => false,
+                                };
+
+                                if done {
+                                    break;
+                                }
+
+                                body.next();
+                            }
+
+                            continue;
+                        }
+
+                        block.is_next = false;
+
+                        // TODO: We can `take` this if it's a `Right`
+                        match block.calling_convention.as_ref() {
+                            Some(Left(cc)) => {
+                                ctx.apply_cc(cc);
+                            }
+                            Some(Right(virt)) => {
+                                ctx.set_state(virt.clone());
+                            }
+                            _ => {}
+                        }
+
+                        ctx.define_label(block.label.label().unwrap().clone());
+
+                        block.has_backwards_callers
+                    };
+
+                    // To reduce memory overhead
+                    if !has_backwards_callers {
+                        entry.remove_entry();
+                    }
+                } else {
+                    panic!("Label defined before being declared");
+                }
             }
-            Operator::Else => {
-                match control_frames.pop() {
-                    Some(ControlFrame {
-                        kind: ControlFrameKind::IfTrue { if_not, end_label },
-                        ty,
-                        stack_depth,
+            Operator::Block {
+                label,
+                has_backwards_callers,
+                params,
+                num_callers,
+            } => {
+                let asm_label = ctx.create_label();
+                blocks.insert(
+                    BrTarget::Label(label),
+                    Block {
+                        label: BrTarget::Label(asm_label),
+                        params: params.len() as _,
+                        calling_convention: None,
+                        is_next: false,
+                        has_backwards_callers,
+                        actual_num_callers: 0,
+                        num_callers,
+                    },
+                );
+            }
+            Operator::Br { target } => {
+                // TODO: We should add the block to the hashmap if we don't have it already
+                let block = blocks.get_mut(&target).unwrap();
+                block.actual_num_callers += 1;
+
+                let should_serialize_args = block.should_serialize_args();
+
+                match block {
+                    Block {
+                        is_next,
+                        label: BrTarget::Label(l),
+                        calling_convention,
                         ..
-                    }) => {
-                        // Finalize if..else block by jumping to the `end_label`.
-                        br(&mut ctx, end_label);
+                    } => {
+                        let cc = if should_serialize_args {
+                            *calling_convention = Some(Left(ctx.serialize_args(block.params)));
+                            None
+                        } else {
+                            calling_convention
+                                .as_ref()
+                                .map(Either::as_ref)
+                                .and_then(Either::left)
+                        };
 
-                        // Define `if_not` label here, so if the corresponding `if` block receives
-                        // 0 it will branch here.
-                        // After that reset stack depth to the value before entering `if` block.
-                        define_label(&mut ctx, if_not);
-                        restore_stack_depth(&mut ctx, stack_depth);
+                        if let Some(cc) = cc {
+                            ctx.pass_block_args(cc);
+                        }
 
-                        // Carry over the `end_label`, so it will be resolved when the corresponding `end`
-                        // is encountered.
-                        //
-                        // Also note that we reset `stack_depth` to the value before entering `if` block.
-                        let mut frame = ControlFrame::new(
-                            ControlFrameKind::IfFalse { end_label },
-                            stack_depth,
-                            ty,
-                        );
-                        control_frames.push(frame);
+                        if !*is_next {
+                            ctx.br(*l);
+                        }
+                    }
+                    Block {
+                        label: BrTarget::Return,
+                        calling_convention: Some(Left(cc)),
+                        ..
+                    } => {
+                        ctx.pass_block_args(cc);
+                        ctx.ret();
+                    }
+                    _ => unimplemented!(),
+                }
+            }
+            Operator::BrIf { then, else_ } => {
+                let (then_block, else_block) = blocks.pair_mut(&then, &else_);
+                // TODO: If actual_num_callers == num_callers then we can remove this block from the hashmap.
+                //       This frees memory and acts as a kind of verification that `num_callers` is set
+                //       correctly. It doesn't help for loops and block ends generated from Wasm.
+                then_block.actual_num_callers += 1;
+                else_block.actual_num_callers += 1;
+
+                let then_block_parts = (then_block.is_next, then_block.label);
+                let else_block_parts = (else_block.is_next, else_block.label);
+
+                // TODO: Use "compatible" cc
+                assert_eq!(then_block.params, else_block.params);
+
+                // TODO: The blocks should have compatible (one must be subset of other?) calling
+                //       conventions or else at least one must have no calling convention. This
+                //       should always be true for converting from WebAssembly AIUI.
+                let f = |ctx: &mut Context<_>| {
+                    let then_block_should_serialize_args = then_block.should_serialize_args();
+                    let else_block_should_serialize_args = else_block.should_serialize_args();
+
+                    match (
+                        &mut then_block.calling_convention,
+                        &mut else_block.calling_convention,
+                    ) {
+                        (Some(Left(ref cc)), ref mut other @ None)
+                        | (ref mut other @ None, Some(Left(ref cc))) => {
+                            **other = Some(Left(cc.clone()));
+
+                            ctx.pass_block_args(cc);
+                        }
+                        (ref mut then_cc @ None, ref mut else_cc @ None) => {
+                            let cc = if then_block_should_serialize_args {
+                                Some(Left(ctx.serialize_args(then_block.params)))
+                            } else if else_block_should_serialize_args {
+                                Some(Left(ctx.serialize_args(else_block.params)))
+                            } else {
+                                Some(Right(ctx.virtual_calling_convention()))
+                            };
+
+                            **then_cc = cc.clone();
+                            **else_cc = cc;
+                        }
+                        _ => unimplemented!(
+                            "Can't pass different params to different sides of `br_if` yet"
+                        ),
                     }
-                    Some(_) => panic!("else expects if block"),
-                    None => panic!("control stack is never empty"),
                 };
-            }
-            Operator::End => {
-                let control_frame = control_frames.pop().expect("control stack is never empty");
 
-                if !control_frame.kind.is_loop() {
-                    // Branches to a control frame with block type directs control flow to the header of the loop
-                    // and we don't need to resolve it here. Branching to other control frames always lead
-                    // control flow to the corresponding `end`.
-                    define_label(&mut ctx, control_frame.kind.br_destination());
-                }
-
-                if let ControlFrameKind::IfTrue { if_not, .. } = control_frame.kind {
-                    // this is `if .. end` construction. Define the `if_not` label here.
-                    define_label(&mut ctx, if_not);
-                }
-
-                restore_stack_depth(&mut ctx, control_frame.outgoing_stack_depth());
-
-                if control_frames.len() == 0 {
-                    // This is the last control frame. Perform the implicit return here.
-                    if return_ty != Type::EmptyBlockType {
-                        prepare_return_value(&mut ctx);
+                match (then_block_parts, else_block_parts) {
+                    ((true, _), (false, BrTarget::Label(else_))) => {
+                        ctx.br_if_false(else_, f);
                     }
+                    ((false, BrTarget::Label(then)), (true, _)) => {
+                        ctx.br_if_true(then, f);
+                    }
+                    ((false, BrTarget::Label(then)), (false, BrTarget::Label(else_))) => {
+                        ctx.br_if_true(then, f);
+                        ctx.br(else_);
+                    }
+                    other => unimplemented!("{:#?}", other),
                 }
             }
-            Operator::I32Eq => {
-                relop_eq_i32(&mut ctx);
+            Operator::BrTable(BrTable { targets, default }) => {
+                use itertools::Itertools;
+
+                let (def, params) = {
+                    let def = blocks.get(&default).unwrap();
+                    (
+                        if def.is_next {
+                            None
+                        } else {
+                            Some(def.label)
+                        },
+                        def.params.clone()
+                    )
+                };
+
+                let target_labels = targets.iter()
+                    .map(|target| blocks.get(target).unwrap().label)
+                    .collect::<Vec<_>>();
+
+                ctx.br_table(target_labels, def, |ctx| {
+                    let mut cc = None;
+                    let mut max_num_callers = Some(0);
+
+                    for target in targets.iter().chain(std::iter::once(&default)).unique() {
+                        let block = blocks.get_mut(target).unwrap();
+                        block.actual_num_callers += 1;
+
+                        if block.calling_convention.is_some() {
+                            assert!(cc.is_none(), "Can't pass different params to different elements of `br_table` yet");
+                            cc = block.calling_convention.clone();
+                        }
+
+                        if let Some(max) = max_num_callers {
+                            max_num_callers = block.num_callers.map(|n| max.max(n));
+                        }
+                    }
+
+                    if let Some(Left(cc)) = &cc {
+                        ctx.pass_block_args(cc);
+                    }
+       
+                    let cc = cc.unwrap_or_else(||
+                        if max_num_callers == Some(1) {
+                            Right(ctx.virtual_calling_convention())
+                        } else {
+                            Left(ctx.serialize_args(params))
+                        }
+                    );
+
+                    for target in targets.iter().chain(std::iter::once(&default)).unique() {
+                        let block = blocks.get_mut(target).unwrap();
+                        block.calling_convention = Some(cc.clone());
+                    }
+                });
             }
-            Operator::I32Add => {
-                add_i32(&mut ctx);
-            }
-            Operator::GetLocal { local_index } => {
-                get_local_i32(&mut ctx, local_index);
-            }
-            Operator::I32Const { value } => {
-                literal_i32(&mut ctx, value);
+            Operator::Swap { depth } => ctx.swap(depth),
+            Operator::Pick { depth } => ctx.pick(depth),
+            Operator::Eq(I32) => ctx.i32_eq(),
+            Operator::Eqz(Size::_32) => ctx.i32_eqz(),
+            Operator::Ne(I32) => ctx.i32_neq(),
+            Operator::Lt(SI32) => ctx.i32_lt_s(),
+            Operator::Le(SI32) => ctx.i32_le_s(),
+            Operator::Gt(SI32) => ctx.i32_gt_s(),
+            Operator::Ge(SI32) => ctx.i32_ge_s(),
+            Operator::Lt(SU32) => ctx.i32_lt_u(),
+            Operator::Le(SU32) => ctx.i32_le_u(),
+            Operator::Gt(SU32) => ctx.i32_gt_u(),
+            Operator::Ge(SU32) => ctx.i32_ge_u(),
+            Operator::Add(I32) => ctx.i32_add(),
+            Operator::Sub(I32) => ctx.i32_sub(),
+            Operator::And(Size::_32) => ctx.i32_and(),
+            Operator::Or(Size::_32) => ctx.i32_or(),
+            Operator::Xor(Size::_32) => ctx.i32_xor(),
+            Operator::Mul(I32) => ctx.i32_mul(),
+            Operator::Div(SU32) => ctx.i32_div_u(),
+            Operator::Div(SI32) => ctx.i32_div_s(),
+            Operator::Rem(sint::I32) => ctx.i32_rem_u(),
+            Operator::Rem(sint::U32) => ctx.i32_rem_s(),
+            Operator::Shl(Size::_32) => ctx.i32_shl(),
+            Operator::Shr(sint::I32) => ctx.i32_shr_s(),
+            Operator::Shr(sint::U32) => ctx.i32_shr_u(),
+            Operator::Rotl(Size::_32) => ctx.i32_rotl(),
+            Operator::Rotr(Size::_32) => ctx.i32_rotr(),
+            Operator::Clz(Size::_32) => ctx.i32_clz(),
+            Operator::Ctz(Size::_32) => ctx.i32_ctz(),
+            Operator::Popcnt(Size::_32) => ctx.i32_popcnt(),
+            Operator::Eq(I64) => ctx.i64_eq(),
+            Operator::Eqz(Size::_64) => ctx.i64_eqz(),
+            Operator::Ne(I64) => ctx.i64_neq(),
+            Operator::Lt(SI64) => ctx.i64_lt_s(),
+            Operator::Le(SI64) => ctx.i64_le_s(),
+            Operator::Gt(SI64) => ctx.i64_gt_s(),
+            Operator::Ge(SI64) => ctx.i64_ge_s(),
+            Operator::Lt(SU64) => ctx.i64_lt_u(),
+            Operator::Le(SU64) => ctx.i64_le_u(),
+            Operator::Gt(SU64) => ctx.i64_gt_u(),
+            Operator::Ge(SU64) => ctx.i64_ge_u(),
+            Operator::Add(I64) => ctx.i64_add(),
+            Operator::Sub(I64) => ctx.i64_sub(),
+            Operator::And(Size::_64) => ctx.i64_and(),
+            Operator::Or(Size::_64) => ctx.i64_or(),
+            Operator::Xor(Size::_64) => ctx.i64_xor(),
+            Operator::Mul(I64) => ctx.i64_mul(),
+            Operator::Shl(Size::_64) => ctx.i64_shl(),
+            Operator::Shr(sint::I64) => ctx.i64_shr_s(),
+            Operator::Shr(sint::U64) => ctx.i64_shr_u(),
+            Operator::Rotl(Size::_64) => ctx.i64_rotl(),
+            Operator::Rotr(Size::_64) => ctx.i64_rotr(),
+            Operator::Clz(Size::_64) => ctx.i64_clz(),
+            Operator::Ctz(Size::_64) => ctx.i64_ctz(),
+            Operator::Popcnt(Size::_64) => ctx.i64_popcnt(),
+            Operator::Add(F32) => ctx.f32_add(),
+            Operator::Mul(F32) => ctx.f32_mul(),
+            Operator::Sub(F32) => ctx.f32_sub(),
+            Operator::Neg(Size::_32) => ctx.f32_neg(),
+            Operator::Gt(SF32) => ctx.f32_gt(),
+            Operator::Ge(SF32) => ctx.f32_ge(),
+            Operator::Lt(SF32) => ctx.f32_lt(),
+            Operator::Le(SF32) => ctx.f32_le(),
+            Operator::Add(F64) => ctx.f64_add(),
+            Operator::Mul(F64) => ctx.f64_mul(),
+            Operator::Sub(F64) => ctx.f64_sub(),
+            Operator::Neg(Size::_64) => ctx.f64_neg(),
+            Operator::Gt(SF64) => ctx.f64_gt(),
+            Operator::Ge(SF64) => ctx.f64_ge(),
+            Operator::Lt(SF64) => ctx.f64_lt(),
+            Operator::Le(SF64) => ctx.f64_le(),
+            Operator::Drop(range) => ctx.drop(range),
+            Operator::Const(val) => ctx.const_(val),
+            Operator::Load { ty: I32, memarg } => ctx.i32_load(memarg.offset)?,
+            Operator::Load { ty: I64, memarg } => ctx.i64_load(memarg.offset)?,
+            Operator::Store { ty: I32, memarg } => ctx.i32_store(memarg.offset)?,
+            Operator::Store { ty: I64, memarg } => ctx.i64_store(memarg.offset)?,
+            Operator::Select => {
+                ctx.select();
             }
             Operator::Call { function_index } => {
-                let callee_ty = translation_ctx.func_type(function_index);
+                let function_index = session
+                    .module_context
+                    .defined_func_index(function_index)
+                    .expect("We don't support host calls yet");
+                let callee_ty = session.module_context.func_type(function_index);
 
                 // TODO: this implementation assumes that this function is locally defined.
-                // TODO: guarantee 16-byte alignment for calls as required by x86-64 ABI
-
-                pass_outgoing_args(&mut ctx, callee_ty.params.len() as u32);
-                call_direct(&mut ctx, function_index, callee_ty.returns.len() as u32);
+                ctx.call_direct(
+                    function_index,
+                    callee_ty.params().iter().map(|t| t.to_microwasm_type()),
+                    callee_ty.returns().len() as u32,
+                );
             }
-            _ => {
-                trap(&mut ctx);
+            Operator::CallIndirect {
+                type_index,
+                table_index,
+            } => {
+                assert_eq!(table_index, 0);
+
+                let callee_ty = session.module_context.signature(type_index);
+
+                // TODO: this implementation assumes that this function is locally defined.
+
+                ctx.call_indirect(
+                    quickhash(callee_ty) as u32,
+                    callee_ty.params().iter().map(|t| t.to_microwasm_type()),
+                    callee_ty.returns().len() as u32,
+                );
+            }
+            op => {
+                unimplemented!("{}", op);
             }
         }
     }
-    epilogue(&mut ctx);
+
+    ctx.epilogue();
 
     Ok(())
 }
diff --git a/src/lib.rs b/src/lib.rs
index 5b63cfb9cc..dea2d99232 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,24 +1,49 @@
-#![feature(plugin)]
+#![feature(
+    plugin,
+    test,
+    const_slice_len,
+    never_type,
+    alloc_layout_extra,
+    try_from,
+    try_trait,
+)]
 #![plugin(dynasm)]
 
+extern crate test;
+#[macro_use]
+extern crate smallvec;
 extern crate capstone;
+extern crate either;
 extern crate failure;
-extern crate wasmparser;
+pub extern crate wasmparser;
 #[macro_use]
 extern crate failure_derive;
+#[macro_use]
+extern crate memoffset;
 extern crate dynasmrt;
-
+extern crate itertools;
+#[cfg(test)]
+#[macro_use]
+extern crate lazy_static;
+#[cfg(test)]
+#[macro_use]
+extern crate quickcheck;
 extern crate wabt;
+// Just so we can implement `Signature` for `cranelift_codegen::ir::Signature`
+extern crate cranelift_codegen;
+extern crate multi_mut;
 
 mod backend;
 mod disassemble;
 mod error;
 mod function_body;
+mod microwasm;
 mod module;
 mod translate_sections;
 
 #[cfg(test)]
 mod tests;
 
-pub use module::translate;
-pub use module::TranslatedModule;
+pub use backend::CodeGenSession;
+pub use function_body::translate_wasm as translate_function;
+pub use module::{translate, ExecutableModule, ModuleContext, Signature, TranslatedModule};
diff --git a/src/microwasm.rs b/src/microwasm.rs
new file mode 100644
index 0000000000..0b85325d72
--- /dev/null
+++ b/src/microwasm.rs
@@ -0,0 +1,1893 @@
+use crate::module::{ModuleContext, SigType, Signature};
+use cranelift_codegen::ir::Signature as CraneliftSignature;
+use smallvec::SmallVec;
+use std::{
+    convert::TryFrom,
+    fmt,
+    iter::{self, FromIterator},
+    ops::RangeInclusive,
+    option::NoneError,
+};
+use wasmparser::{
+    FunctionBody, Ieee32, Ieee64, MemoryImmediate, Operator as WasmOperator, OperatorsReader,
+};
+
+pub fn dis<L>(function_name: impl fmt::Display, microwasm: &[Operator<L>]) -> String
+where
+    BrTarget<L>: fmt::Display,
+    L: Clone,
+{
+    use std::fmt::Write;
+
+    const DISASSEMBLE_BLOCK_DEFS: bool = true;
+
+    let mut asm = format!(".fn_{}:\n", function_name);
+    let mut out = String::new();
+
+    let p = "      ";
+    for op in microwasm {
+        if op.is_label() {
+            writeln!(asm, "{}", op).unwrap();
+        } else if op.is_block() {
+            writeln!(out, "{}", op).unwrap();
+        } else {
+            writeln!(asm, "{}{}", p, op).unwrap();
+        }
+    }
+
+    let out = if DISASSEMBLE_BLOCK_DEFS {
+        writeln!(out).unwrap();
+        writeln!(out, "{}", asm).unwrap();
+        out
+    } else {
+        asm
+    };
+
+    out
+}
+
+/// A constant value embedded in the instructions
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Value {
+    I32(i32),
+    I64(i64),
+    F32(Ieee32),
+    F64(Ieee64),
+}
+
+impl fmt::Display for Value {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Value::I32(v) => write!(f, "{}i32", v),
+            Value::I64(v) => write!(f, "{}i64", v),
+            Value::F32(v) => write!(f, "{}f32", f32::from_bits(v.bits())),
+            Value::F64(v) => write!(f, "{}f64", f64::from_bits(v.bits())),
+        }
+    }
+}
+
+impl Value {
+    pub fn as_int(self) -> Option<i64> {
+        self.as_i64().or_else(|| self.as_i32().map(|i| i as _))
+    }
+
+    pub fn as_bytes(self) -> i64 {
+        match self {
+            Value::I32(val) => val as _,
+            Value::I64(val) => val,
+            Value::F32(val) => val.0 as _,
+            Value::F64(val) => val.0 as _,
+        }
+    }
+
+    pub fn as_i32(self) -> Option<i32> {
+        match self {
+            Value::I32(val) => Some(val),
+            _ => None,
+        }
+    }
+
+    pub fn as_i64(self) -> Option<i64> {
+        match self {
+            Value::I64(val) => Some(val),
+            _ => None,
+        }
+    }
+
+    pub fn as_f32(self) -> Option<Ieee32> {
+        match self {
+            Value::F32(val) => Some(val),
+            _ => None,
+        }
+    }
+
+    pub fn as_f64(self) -> Option<Ieee64> {
+        match self {
+            Value::F64(val) => Some(val),
+            _ => None,
+        }
+    }
+
+    pub fn type_(&self) -> SignlessType {
+        match self {
+            Value::I32(_) => Type::Int(Size::_32),
+            Value::I64(_) => Type::Int(Size::_64),
+            Value::F32(Ieee32(_)) => Type::Float(Size::_32),
+            Value::F64(Ieee64(_)) => Type::Float(Size::_64),
+        }
+    }
+
+    fn default_for_type(ty: SignlessType) -> Self {
+        match ty {
+            Type::Int(Size::_32) => Value::I32(0),
+            Type::Int(Size::_64) => Value::I64(0),
+            Type::Float(Size::_32) => Value::F32(Ieee32(0)),
+            Type::Float(Size::_64) => Value::F64(Ieee64(0)),
+        }
+    }
+}
+
+impl From<i32> for Value {
+    fn from(other: i32) -> Self {
+        Value::I32(other)
+    }
+}
+impl From<i64> for Value {
+    fn from(other: i64) -> Self {
+        Value::I64(other)
+    }
+}
+impl From<u32> for Value {
+    fn from(other: u32) -> Self {
+        Value::I32(other as _)
+    }
+}
+impl From<u64> for Value {
+    fn from(other: u64) -> Self {
+        Value::I64(other as _)
+    }
+}
+impl From<Ieee32> for Value {
+    fn from(other: Ieee32) -> Self {
+        Value::F32(other)
+    }
+}
+impl From<Ieee64> for Value {
+    fn from(other: Ieee64) -> Self {
+        Value::F64(other)
+    }
+}
+
+/// Whether to interpret an integer as signed or unsigned
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Signedness {
+    Signed,
+    Unsigned,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Size {
+    _32,
+    _64,
+}
+
+type Int = Size;
+type Float = Size;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct SignfulInt(Signedness, Size);
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Type<I> {
+    Int(I),
+    Float(Size),
+}
+
+pub trait IntoType<T> {
+    fn into_type() -> T;
+}
+
+impl IntoType<SignlessType> for i32 {
+    fn into_type() -> SignlessType {
+        I32
+    }
+}
+
+impl IntoType<SignlessType> for i64 {
+    fn into_type() -> SignlessType {
+        I64
+    }
+}
+
+impl IntoType<SignlessType> for u32 {
+    fn into_type() -> SignlessType {
+        I32
+    }
+}
+
+impl IntoType<SignlessType> for u64 {
+    fn into_type() -> SignlessType {
+        I64
+    }
+}
+
+impl IntoType<SignlessType> for f32 {
+    fn into_type() -> SignlessType {
+        F32
+    }
+}
+
+impl IntoType<SignlessType> for f64 {
+    fn into_type() -> SignlessType {
+        F64
+    }
+}
+
+impl<I> Type<I> {
+    pub fn for_<T: IntoType<Self>>() -> Self {
+        T::into_type()
+    }
+}
+
+impl fmt::Display for SignfulType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Type::Int(i) => write!(f, "{}", i),
+            Type::Float(Size::_32) => write!(f, "f32"),
+            Type::Float(Size::_64) => write!(f, "f64"),
+        }
+    }
+}
+
+impl fmt::Display for SignlessType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Type::Int(Size::_32) => write!(f, "i32"),
+            Type::Int(Size::_64) => write!(f, "i64"),
+            Type::Float(Size::_32) => write!(f, "f32"),
+            Type::Float(Size::_64) => write!(f, "f64"),
+        }
+    }
+}
+
+impl fmt::Display for SignfulInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            SignfulInt(Signedness::Signed, Size::_32) => write!(f, "i32"),
+            SignfulInt(Signedness::Unsigned, Size::_32) => write!(f, "u32"),
+            SignfulInt(Signedness::Signed, Size::_64) => write!(f, "i64"),
+            SignfulInt(Signedness::Unsigned, Size::_64) => write!(f, "u64"),
+        }
+    }
+}
+
+pub type SignlessType = Type<Size>;
+pub type SignfulType = Type<SignfulInt>;
+
+pub const I32: SignlessType = Type::Int(Size::_32);
+pub const I64: SignlessType = Type::Int(Size::_64);
+pub const F32: SignlessType = Type::Float(Size::_32);
+pub const F64: SignlessType = Type::Float(Size::_64);
+
+pub mod sint {
+    use super::{Signedness, SignfulInt, Size};
+
+    pub const I32: SignfulInt = SignfulInt(Signedness::Signed, Size::_32);
+    pub const I64: SignfulInt = SignfulInt(Signedness::Signed, Size::_64);
+    pub const U32: SignfulInt = SignfulInt(Signedness::Unsigned, Size::_32);
+    pub const U64: SignfulInt = SignfulInt(Signedness::Unsigned, Size::_64);
+}
+
+pub const SI32: SignfulType = Type::Int(sint::I32);
+pub const SI64: SignfulType = Type::Int(sint::I64);
+pub const SU32: SignfulType = Type::Int(sint::U32);
+pub const SU64: SignfulType = Type::Int(sint::U64);
+pub const SF32: SignfulType = Type::Float(Size::_32);
+pub const SF64: SignfulType = Type::Float(Size::_64);
+
+impl SignlessType {
+    pub fn from_wasm(other: wasmparser::Type) -> Option<Self> {
+        use wasmparser::Type;
+
+        match other {
+            Type::I32 => Some(I32),
+            Type::I64 => Some(I64),
+            Type::F32 => Some(F32),
+            Type::F64 => Some(F64),
+            Type::EmptyBlockType => None,
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl TryFrom<wasmparser::Type> for SignlessType {
+    type Error = NoneError;
+
+    fn try_from(other: wasmparser::Type) -> Result<SignlessType, NoneError> {
+        Ok(SignlessType::from_wasm(other)?)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct BrTable<L> {
+    pub targets: Vec<BrTarget<L>>,
+    pub default: BrTarget<L>,
+}
+
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum NameTag {
+    Header,
+    Else,
+    End,
+}
+
+pub type WasmLabel = (u32, NameTag);
+
+trait Label {
+    // TODO
+}
+
+// TODO: This is for Wasm blocks - we should have an increasing ID for each block that we hit.
+impl Label for (u32, NameTag) {}
+
+type OperatorFromWasm = Operator<WasmLabel>;
+
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+pub enum BrTarget<L> {
+    Return,
+    Label(L),
+}
+
+impl<L> BrTarget<L> {
+    pub fn label(&self) -> Option<&L> {
+        match self {
+            BrTarget::Return => None,
+            BrTarget::Label(l) => Some(l),
+        }
+    }
+}
+
+impl fmt::Display for BrTarget<WasmLabel> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            BrTarget::Return => write!(f, ".return"),
+            BrTarget::Label((i, NameTag::Header)) => write!(f, ".L{}", i),
+            BrTarget::Label((i, NameTag::Else)) => write!(f, ".L{}_else", i),
+            BrTarget::Label((i, NameTag::End)) => write!(f, ".L{}_end", i),
+        }
+    }
+}
+
+impl fmt::Display for BrTarget<&str> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            BrTarget::Return => write!(f, ".return"),
+            BrTarget::Label(l) => write!(f, ".L{}", l),
+        }
+    }
+}
+
+// TODO: Explicit VmCtx?
+#[derive(Debug, Clone)]
+pub enum Operator<Label> {
+    /// Explicit trap instruction
+    Unreachable,
+    /// Define metadata for a block - its label, its signature, whether it has backwards callers etc. It
+    /// is an error to branch to a block that has yet to be defined.
+    Block {
+        label: Label,
+        // TODO: Do we need this?
+        params: Vec<SignlessType>,
+        // TODO: Ideally we'd have `num_backwards_callers` but we can't know that for WebAssembly
+        has_backwards_callers: bool,
+        num_callers: Option<u32>,
+    },
+    /// Start a new block. It is an error if the previous block has not been closed by emitting a `Br` or
+    /// `BrTable`.
+    Label(Label),
+    /// Unconditionally break to a new block. This the parameters off the stack and passes them into
+    /// the new block. Any remaining elements on the stack are discarded.
+    Br {
+        /// Returning from the function is just calling the "return" block
+        target: BrTarget<Label>,
+    },
+    /// Pop a value off the top of the stack, jump to the `else_` label if this value is `true`
+    /// and the `then` label otherwise. The `then` and `else_` blocks must have the same parameters.
+    BrIf {
+        /// Label to jump to if the value at the top of the stack is true
+        then: BrTarget<Label>,
+        /// Label to jump to if the value at the top of the stack is false
+        else_: BrTarget<Label>,
+    },
+    /// Pop a value off the top of the stack, jump to `table[value.min(table.len() - 1)]`. All elements
+    /// in the table must have the same parameters.
+    BrTable(
+        /// The table of labels to jump to - the index should be clamped to the length of the table
+        BrTable<Label>,
+    ),
+    /// Call a function
+    Call {
+        function_index: u32,
+    },
+    /// Pop an `i32` off the top of the stack, index into the table at `table_index` and call that function
+    CallIndirect {
+        type_index: u32,
+        table_index: u32,
+    },
+    /// Pop an element off of the stack and discard it.
+    Drop(RangeInclusive<u32>),
+    /// Pop an `i32` off of the stack and 2 elements off of the stack, call them `A` and `B` where `A` is the
+    /// first element popped and `B` is the second. If the `i32` is 0 then discard `B` and push `A` back onto
+    /// the stack, otherwise discard `A` and push `B` back onto the stack.
+    Select,
+    /// Duplicate the element at depth `depth` to the top of the stack. This can be used to implement
+    /// `GetLocal`.
+    Pick {
+        depth: u32,
+    },
+    /// Swap the top element of the stack with the element at depth `depth`. This can be used to implement
+    /// `SetLocal`.
+    // TODO: Is it better to have `Swap`, to have `Pull` (which moves the `nth` element instead of swapping)
+    //       or to have both?
+    Swap {
+        depth: u32,
+    },
+    GetGlobal {
+        index: u32,
+    },
+    SetGlobal {
+        index: u32,
+    },
+    Load {
+        ty: SignlessType,
+        memarg: MemoryImmediate,
+    },
+    Load8 {
+        ty: SignfulInt,
+        memarg: MemoryImmediate,
+    },
+    Load16 {
+        ty: SignfulInt,
+        memarg: MemoryImmediate,
+    },
+    // Only available for {I,U}64
+    // TODO: Roll this into `Load` somehow?
+    Load32 {
+        sign: Signedness,
+        memarg: MemoryImmediate,
+    },
+    Store {
+        ty: SignlessType,
+        memarg: MemoryImmediate,
+    },
+    Store8 {
+        /// `ty` on integers
+        ty: Int,
+        memarg: MemoryImmediate,
+    },
+    Store16 {
+        /// `ty` on integers
+        ty: Int,
+        memarg: MemoryImmediate,
+    },
+    // Only available for I64
+    // TODO: Roll this into `Store` somehow?
+    Store32 {
+        memarg: MemoryImmediate,
+    },
+    MemorySize {
+        reserved: u32,
+    },
+    MemoryGrow {
+        reserved: u32,
+    },
+    Const(Value),
+    RefNull,
+    RefIsNull,
+    Eq(SignlessType),
+    Ne(SignlessType),
+    /// `eqz` on integers
+    Eqz(Int),
+    Lt(SignfulType),
+    Gt(SignfulType),
+    Le(SignfulType),
+    Ge(SignfulType),
+    Add(SignlessType),
+    Sub(SignlessType),
+    Mul(SignlessType),
+    /// `clz` on integers
+    Clz(Int),
+    /// `ctz` on integers
+    Ctz(Int),
+    /// `popcnt` on integers
+    Popcnt(Int),
+    Div(SignfulType),
+    Rem(SignfulInt),
+    And(Int),
+    Or(Int),
+    Xor(Int),
+    Shl(Int),
+    Shr(SignfulInt),
+    Rotl(Int),
+    Rotr(Int),
+    Abs(Float),
+    Neg(Float),
+    Ceil(Float),
+    Floor(Float),
+    Trunc(Float),
+    Nearest(Float),
+    Sqrt(Float),
+    Min(Float),
+    Max(Float),
+    Copysign(Float),
+    I32WrapFromI64,
+    ITruncFromF {
+        input_ty: Float,
+        output_ty: SignfulInt,
+    },
+    FConvertFromI {
+        input_ty: SignfulInt,
+        output_ty: Float,
+    },
+    F32DemoteFromF64,
+    F64PromoteFromF32,
+    I32ReinterpretFromF32,
+    I64ReinterpretFromF64,
+    F32ReinterpretFromI32,
+    F64ReinterpretFromI64,
+    // Only available for input I32 and output I64
+    Extend {
+        sign: Signedness,
+    },
+    // 0xFC operators
+    /// Non-trapping Float-to-int conversion
+    ISatTruncFromF {
+        input_ty: Float,
+        output_ty: SignfulInt,
+    },
+
+    // 0xFC operators
+    // bulk memory https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md
+    MemoryInit {
+        segment: u32,
+    },
+    DataDrop {
+        segment: u32,
+    },
+    MemoryCopy,
+    MemoryFill,
+    TableInit {
+        segment: u32,
+    },
+    ElemDrop {
+        segment: u32,
+    },
+    TableCopy,
+}
+
+impl<L> Operator<L> {
+    pub fn is_label(&self) -> bool {
+        match self {
+            Operator::Label(..) => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_block(&self) -> bool {
+        match self {
+            Operator::Block { .. } => true,
+            _ => false,
+        }
+    }
+
+    pub fn end(params: Vec<SignlessType>, label: L) -> Self {
+        Operator::Block {
+            params,
+            label,
+            has_backwards_callers: false,
+            // TODO
+            num_callers: None,
+        }
+    }
+
+    pub fn block(params: Vec<SignlessType>, label: L) -> Self {
+        Operator::Block {
+            params,
+            label,
+            has_backwards_callers: false,
+            num_callers: Some(1),
+        }
+    }
+
+    pub fn loop_(params: Vec<SignlessType>, label: L) -> Self {
+        Operator::Block {
+            params,
+            label,
+            has_backwards_callers: true,
+            num_callers: None,
+        }
+    }
+}
+
+impl<L> fmt::Display for Operator<L>
+where
+    BrTarget<L>: fmt::Display,
+    L: Clone,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Operator::Unreachable => write!(f, "unreachable"),
+            Operator::Label(label) => write!(f, "{}:", BrTarget::Label(label.clone())),
+            Operator::Block {
+                label,
+                params,
+                has_backwards_callers,
+                num_callers,
+            } => {
+                write!(f, "def {} :: [", BrTarget::Label(label.clone()))?;
+                let mut iter = params.iter();
+                if let Some(p) = iter.next() {
+                    write!(f, "{}", p)?;
+                    for p in iter {
+                        write!(f, ", {}", p)?;
+                    }
+                }
+                write!(f, "]")?;
+
+                if *has_backwards_callers {
+                    write!(f, " has_backwards_callers")?;
+                }
+
+                if let Some(n) = num_callers {
+                    write!(f, " num_callers={}", n)?;
+                }
+
+                Ok(())
+            }
+            Operator::Br { target } => write!(f, "br {}", target),
+            Operator::BrIf { then, else_ } => write!(f, "br_if {}, {}", then, else_),
+            Operator::BrTable(BrTable { targets, default }) => {
+                write!(f, "br_table [")?;
+                let mut iter = targets.iter();
+                if let Some(p) = iter.next() {
+                    write!(f, "{}", p)?;
+                    for p in iter {
+                        write!(f, ", {}", p)?;
+                    }
+                }
+
+                write!(f, "], {}", default)
+            },
+            Operator::Call { function_index } => write!(f, "call {}", function_index),
+            Operator::CallIndirect { .. } => write!(f, "call_indirect"),
+            Operator::Drop(range) => {
+                write!(f, "drop")?;
+
+                match range.clone().into_inner() {
+                    (0, 0) => {}
+                    (start, end) if start == end => {
+                        write!(f, " {}", start)?;
+                    }
+                    (start, end) => {
+                        write!(f, " {}..={}", start, end)?;
+                    }
+                }
+
+                Ok(())
+            }
+            Operator::Select => write!(f, "select"),
+            Operator::Pick { depth } => write!(f, "pick {}", depth),
+            Operator::Swap { depth } => write!(f, "swap {}", depth),
+            Operator::Load { ty, memarg } => {
+                write!(f, "{}.load {}, {}", ty, memarg.flags, memarg.offset)
+            }
+            Operator::Load8 { ty, memarg } => {
+                write!(f, "{}.load8 {}, {}", ty, memarg.flags, memarg.offset)
+            }
+            Operator::Load16 { ty, memarg } => {
+                write!(f, "{}.load16 {}, {}", ty, memarg.flags, memarg.offset)
+            }
+            Operator::Load32 { sign, memarg } => write!(
+                f,
+                "{}.load32 {}, {}",
+                SignfulInt(*sign, Size::_64),
+                memarg.flags,
+                memarg.offset
+            ),
+            Operator::Store { ty, memarg } => {
+                write!(f, "{}.store {}, {}", ty, memarg.flags, memarg.offset)
+            }
+            Operator::Store8 { ty, memarg } => write!(
+                f,
+                "{}.store8 {}, {}",
+                SignfulInt(Signedness::Unsigned, *ty),
+                memarg.flags,
+                memarg.offset
+            ),
+            Operator::Store16 { ty, memarg } => write!(
+                f,
+                "{}.store16 {}, {}",
+                SignfulInt(Signedness::Unsigned, *ty),
+                memarg.flags,
+                memarg.offset
+            ),
+            Operator::Store32 { memarg } => {
+                write!(f, "u64.store32 {}, {}", memarg.flags, memarg.offset)
+            }
+            Operator::MemorySize { .. } => write!(f, "memory.size"),
+            Operator::MemoryGrow { .. } => write!(f, "memory.grow"),
+            Operator::Const(val) => write!(f, "const {}", val),
+            Operator::RefNull => write!(f, "refnull"),
+            Operator::RefIsNull => write!(f, "refisnull"),
+            Operator::Eq(ty) => write!(f, "{}.eq", ty),
+            Operator::Ne(ty) => write!(f, "{}.ne", ty),
+            Operator::Eqz(ty) => write!(f, "{}.eqz", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Lt(ty) => write!(f, "{}.lt", ty),
+            Operator::Gt(ty) => write!(f, "{}.gt", ty),
+            Operator::Le(ty) => write!(f, "{}.le", ty),
+            Operator::Ge(ty) => write!(f, "{}.ge", ty),
+            Operator::Add(ty) => write!(f, "{}.add", ty),
+            Operator::Sub(ty) => write!(f, "{}.sub", ty),
+            Operator::Mul(ty) => write!(f, "{}.mul", ty),
+            Operator::Clz(ty) => write!(f, "{}.clz", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Ctz(ty) => write!(f, "{}.ctz", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Popcnt(ty) => write!(f, "{}.popcnt", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Div(ty) => write!(f, "{}.div", ty),
+            Operator::Rem(ty) => write!(f, "{}.rem", ty),
+            Operator::And(ty) => write!(f, "{}.and", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Or(ty) => write!(f, "{}.or", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Xor(ty) => write!(f, "{}.xor", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Shl(ty) => write!(f, "{}.shl", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Shr(ty) => write!(f, "{}.shr", ty),
+            Operator::Rotl(ty) => write!(f, "{}.rotl", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Rotr(ty) => write!(f, "{}.rotr", SignfulInt(Signedness::Unsigned, *ty)),
+            Operator::Abs(ty) => write!(f, "{}.abs", Type::<Size>::Float(*ty)),
+            Operator::Neg(ty) => write!(f, "{}.neg", Type::<Size>::Float(*ty)),
+            Operator::Ceil(ty) => write!(f, "{}.ceil", Type::<Size>::Float(*ty)),
+            Operator::Floor(ty) => write!(f, "{}.floor", Type::<Size>::Float(*ty)),
+            Operator::Trunc(ty) => write!(f, "{}.trunc", Type::<Size>::Float(*ty)),
+            Operator::Nearest(ty) => write!(f, "{}.nearest", Type::<Size>::Float(*ty)),
+            Operator::Sqrt(ty) => write!(f, "{}.sqrt", Type::<Size>::Float(*ty)),
+            Operator::Min(ty) => write!(f, "{}.min", Type::<Size>::Float(*ty)),
+            Operator::Max(ty) => write!(f, "{}.max", Type::<Size>::Float(*ty)),
+            Operator::Copysign(ty) => write!(f, "{}.copysign", Type::<Size>::Float(*ty)),
+            Operator::I32WrapFromI64 => write!(f, "i32.wrapfromi64"),
+            Operator::F32DemoteFromF64 => write!(f, "f32.demotefromf64"),
+            Operator::F64PromoteFromF32 => write!(f, "f64.promotefromf32"),
+            Operator::I32ReinterpretFromF32 => write!(f, "i32.reinterpretfromf32"),
+            Operator::I64ReinterpretFromF64 => write!(f, "i64.reinterpretfromf64"),
+            Operator::F32ReinterpretFromI32 => write!(f, "f32.reinterpretfromi32"),
+            Operator::F64ReinterpretFromI64 => write!(f, "f64.reinterpretfromi64"),
+            Operator::MemoryCopy => write!(f, "memory.copy"),
+            Operator::MemoryFill => write!(f, "memory.fill"),
+            Operator::TableCopy => write!(f, "table.copy"),
+            _ => unimplemented!(),
+        }
+    }
+}
+
+/// Type of a control frame.
+#[derive(Debug, Clone, PartialEq)]
+enum ControlFrameKind {
+    /// A regular block frame.
+    ///
+    /// Can be used for an implicit function block.
+    Block {
+        needs_end_label: bool,
+    },
+    Function,
+    /// Loop frame (branching to the beginning of block).
+    Loop,
+    /// True-subblock of if expression.
+    If {
+        params: Vec<SignlessType>,
+        has_else: bool,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct ControlFrame {
+    id: u32,
+    arguments: u32,
+    returns: u32,
+    kind: ControlFrameKind,
+}
+
+impl ControlFrame {
+    fn needs_end_label(&self) -> bool {
+        match self.kind {
+            ControlFrameKind::Block { needs_end_label } => needs_end_label,
+            ControlFrameKind::If { .. } => true,
+            ControlFrameKind::Loop | ControlFrameKind::Function => false,
+        }
+    }
+
+    fn mark_branched_to(&mut self) {
+        match &mut self.kind {
+            ControlFrameKind::Block { needs_end_label } => *needs_end_label = true,
+            _ => {}
+        }
+    }
+
+    fn br_target(&self) -> BrTarget<(u32, NameTag)> {
+        match self.kind {
+            ControlFrameKind::Loop => BrTarget::Label((self.id, NameTag::Header)),
+            ControlFrameKind::Function => BrTarget::Return,
+            ControlFrameKind::Block { .. } | ControlFrameKind::If { .. } => {
+                BrTarget::Label((self.id, NameTag::End))
+            }
+        }
+    }
+
+    fn params(&self) -> Option<&[SignlessType]> {
+        match &self.kind {
+            ControlFrameKind::If { params, .. } => Some(params),
+            _ => None,
+        }
+    }
+}
+
+pub struct MicrowasmConv<'a, 'b, M> {
+    // TODO: Maybe have a `ConvInner` type and have this wrap an `Option` so that
+    //       we can dealloc everything when we've finished emitting
+    is_done: bool,
+    consts_to_emit: Option<Vec<Value>>,
+    stack: Vec<SignlessType>,
+    internal: OperatorsReader<'a>,
+    module: &'b M,
+    current_id: u32,
+    control_frames: Vec<ControlFrame>,
+    unreachable: bool,
+}
+
+#[derive(Debug)]
+enum SigT {
+    T,
+    Concrete(SignlessType),
+}
+
+impl From<SignlessType> for SigT {
+    fn from(other: SignlessType) -> SigT {
+        SigT::Concrete(other)
+    }
+}
+
+#[derive(Debug)]
+pub struct OpSig {
+    input: SmallVec<[SigT; 3]>,
+    output: SmallVec<[SigT; 3]>,
+}
+
+impl OpSig {
+    #[inline(always)]
+    fn new<I0, I1>(input: I0, output: I1) -> Self
+    where
+        I0: IntoIterator<Item = SigT>,
+        I1: IntoIterator<Item = SigT>,
+    {
+        OpSig {
+            input: SmallVec::from_iter(input),
+            output: SmallVec::from_iter(output),
+        }
+    }
+
+    fn none() -> Self {
+        Self::new(None, None)
+    }
+}
+
+impl<T> From<&'_ T> for OpSig
+where
+    T: Signature,
+{
+    fn from(other: &T) -> Self {
+        OpSig::new(
+            other
+                .params()
+                .iter()
+                .map(|t| SigT::Concrete(t.to_microwasm_type())),
+            other
+                .returns()
+                .iter()
+                .map(|t| SigT::Concrete(t.to_microwasm_type())),
+        )
+    }
+}
+
+impl<'a, 'b, M: ModuleContext> MicrowasmConv<'a, 'b, M>
+where
+    for<'any> &'any M::Signature: Into<OpSig>,
+{
+    pub fn new(
+        context: &'b M,
+        params: impl IntoIterator<Item = SignlessType>,
+        returns: impl IntoIterator<Item = SignlessType>,
+        reader: &'a FunctionBody,
+    ) -> Self {
+        // TODO: Don't panic!
+        let locals_reader = reader
+            .get_locals_reader()
+            .expect("Failed to get locals reader");
+        let mut locals = Vec::from_iter(params);
+        let mut consts = Vec::new();
+
+        for loc in locals_reader {
+            let (count, ty) = loc.expect("Getting local failed");
+            let ty = Type::from_wasm(ty).expect("Invalid local type");
+            locals.extend(std::iter::repeat(ty).take(count as _));
+            consts.extend(
+                std::iter::repeat(ty)
+                    .map(Value::default_for_type)
+                    .take(count as _),
+            )
+        }
+
+        let num_locals = locals.len() as _;
+
+        let mut out = Self {
+            is_done: false,
+            stack: locals,
+            module: context,
+            consts_to_emit: Some(consts),
+            internal: reader
+                .get_operators_reader()
+                .expect("Failed to get operators reader"),
+            current_id: 0,
+            control_frames: vec![],
+            unreachable: false,
+        };
+
+        let id = out.next_id();
+        out.control_frames.push(ControlFrame {
+            id,
+            arguments: num_locals,
+            returns: returns.into_iter().count() as _,
+            kind: ControlFrameKind::Function,
+        });
+
+        out
+    }
+
+    fn op_sig(&self, op: &WasmOperator) -> OpSig {
+        use self::SigT::T;
+        use std::iter::{empty as none, once};
+
+        #[inline(always)]
+        fn one<A>(a: A) -> impl IntoIterator<Item = SigT>
+        where
+            A: Into<SigT>,
+        {
+            once(a.into())
+        }
+
+        #[inline(always)]
+        fn two<A, B>(a: A, b: B) -> impl IntoIterator<Item = SigT>
+        where
+            A: Into<SigT>,
+            B: Into<SigT>,
+        {
+            once(a.into()).chain(once(b.into()))
+        }
+
+        #[inline(always)]
+        fn three<A, B, C>(a: A, b: B, c: C) -> impl IntoIterator<Item = SigT>
+        where
+            A: Into<SigT>,
+            B: Into<SigT>,
+            C: Into<SigT>,
+        {
+            once(a.into()).chain(once(b.into())).chain(once(c.into()))
+        }
+
+        macro_rules! sig {
+            (@iter $a:expr, $b:expr, $c:expr) => { three($a, $b, $c) };
+            (@iter $a:expr, $b:expr) => { two($a, $b) };
+            (@iter $a:expr) => { one($a) };
+            (@iter) => { none() };
+            (($($t:expr),*) -> ($($o:expr),*)) => {
+                OpSig::new(sig!(@iter $($t),*), sig!(@iter $($o),*))
+            };
+        }
+
+        match op {
+            WasmOperator::Unreachable => OpSig::none(),
+            WasmOperator::Nop => OpSig::none(),
+
+            WasmOperator::Block { .. } => OpSig::none(),
+            WasmOperator::Loop { .. } => OpSig::none(),
+            WasmOperator::If { .. } => sig!((I32) -> ()),
+            WasmOperator::Else => OpSig::none(),
+            WasmOperator::End => OpSig::none(),
+
+            WasmOperator::Br { .. } => OpSig::none(),
+            WasmOperator::BrIf { .. } => sig!((I32) -> ()),
+            WasmOperator::BrTable { .. } => sig!((I32) -> ()),
+            WasmOperator::Return => OpSig::none(),
+
+            WasmOperator::Call { function_index } => {
+                let func_type = self.module.func_type(*function_index);
+                func_type.into()
+            }
+            WasmOperator::CallIndirect { index, .. } => {
+                let func_type = self.module.signature(*index);
+                let mut out = func_type.into();
+                out.input.push(I32.into());
+                out
+            }
+
+            WasmOperator::Drop => sig!((T) -> ()),
+
+            // `Select` pops 3 elements and pushes 1
+            WasmOperator::Select => sig!((T, T, I32) -> (T)),
+
+            WasmOperator::GetLocal { local_index } => {
+                let ty = self.stack[*local_index as usize];
+
+                sig!(() -> (ty))
+            }
+            WasmOperator::SetLocal { local_index } => {
+                let ty = self.stack[*local_index as usize];
+
+                sig!((ty) -> ())
+            }
+            WasmOperator::TeeLocal { local_index } => {
+                let ty = self.stack[*local_index as usize];
+
+                sig!((ty) -> (ty))
+            }
+
+            WasmOperator::GetGlobal { global_index: _ } => unimplemented!(),
+            WasmOperator::SetGlobal { global_index: _ } => unimplemented!(),
+
+            WasmOperator::F32Load { .. } => sig!((I32) -> (F32)),
+            WasmOperator::F64Load { .. } => sig!((I32) -> (F64)),
+
+            WasmOperator::I32Load { .. }
+            | WasmOperator::I32Load8S { .. }
+            | WasmOperator::I32Load8U { .. }
+            | WasmOperator::I32Load16S { .. }
+            | WasmOperator::I32Load16U { .. } => sig!((I32) -> (I32)),
+
+            WasmOperator::I64Load { .. }
+            | WasmOperator::I64Load8S { .. }
+            | WasmOperator::I64Load8U { .. }
+            | WasmOperator::I64Load16S { .. }
+            | WasmOperator::I64Load16U { .. }
+            | WasmOperator::I64Load32S { .. }
+            | WasmOperator::I64Load32U { .. } => sig!((I32) -> (I64)),
+
+            WasmOperator::F32Store { .. } => sig!((I32, F32) -> ()),
+            WasmOperator::F64Store { .. } => sig!((I32, F64) -> ()),
+            WasmOperator::I32Store { .. }
+            | WasmOperator::I32Store8 { .. }
+            | WasmOperator::I32Store16 { .. } => sig!((I32, I32) -> ()),
+            WasmOperator::I64Store { .. }
+            | WasmOperator::I64Store8 { .. }
+            | WasmOperator::I64Store16 { .. }
+            | WasmOperator::I64Store32 { .. } => sig!((I32, I64) -> ()),
+
+            WasmOperator::MemorySize { .. } => sig!(() -> (I32)),
+            WasmOperator::MemoryGrow { .. } => sig!((I32) -> (I32)),
+
+            WasmOperator::I32Const { .. } => sig!(() -> (I32)),
+            WasmOperator::I64Const { .. } => sig!(() -> (I64)),
+            WasmOperator::F32Const { .. } => sig!(() -> (F32)),
+            WasmOperator::F64Const { .. } => sig!(() -> (F64)),
+
+            WasmOperator::RefNull => unimplemented!(),
+            WasmOperator::RefIsNull => unimplemented!(),
+
+            // All comparison operators remove 2 elements and push 1
+            WasmOperator::I32Eqz => sig!((I32) -> (I32)),
+            WasmOperator::I32Eq
+            | WasmOperator::I32Ne
+            | WasmOperator::I32LtS
+            | WasmOperator::I32LtU
+            | WasmOperator::I32GtS
+            | WasmOperator::I32GtU
+            | WasmOperator::I32LeS
+            | WasmOperator::I32LeU
+            | WasmOperator::I32GeS
+            | WasmOperator::I32GeU => sig!((I32, I32) -> (I32)),
+
+            WasmOperator::I64Eqz => sig!((I64) -> (I32)),
+            WasmOperator::I64Eq
+            | WasmOperator::I64Ne
+            | WasmOperator::I64LtS
+            | WasmOperator::I64LtU
+            | WasmOperator::I64GtS
+            | WasmOperator::I64GtU
+            | WasmOperator::I64LeS
+            | WasmOperator::I64LeU
+            | WasmOperator::I64GeS
+            | WasmOperator::I64GeU => sig!((I64, I64) -> (I32)),
+
+            WasmOperator::F32Eq
+            | WasmOperator::F32Ne
+            | WasmOperator::F32Lt
+            | WasmOperator::F32Gt
+            | WasmOperator::F32Le
+            | WasmOperator::F32Ge => sig!((F32) -> (I32)),
+
+            WasmOperator::F64Eq
+            | WasmOperator::F64Ne
+            | WasmOperator::F64Lt
+            | WasmOperator::F64Gt
+            | WasmOperator::F64Le
+            | WasmOperator::F64Ge => sig!((F64) -> (I32)),
+
+            WasmOperator::I32Clz | WasmOperator::I32Ctz | WasmOperator::I32Popcnt => {
+                sig!((I32) -> (I32))
+            }
+            WasmOperator::I64Clz | WasmOperator::I64Ctz | WasmOperator::I64Popcnt => {
+                sig!((I64) -> (I64))
+            }
+
+            WasmOperator::I32Add
+            | WasmOperator::I32Sub
+            | WasmOperator::I32Mul
+            | WasmOperator::I32DivS
+            | WasmOperator::I32DivU
+            | WasmOperator::I32RemS
+            | WasmOperator::I32RemU
+            | WasmOperator::I32And
+            | WasmOperator::I32Or
+            | WasmOperator::I32Xor
+            | WasmOperator::I32Shl
+            | WasmOperator::I32ShrS
+            | WasmOperator::I32ShrU
+            | WasmOperator::I32Rotl
+            | WasmOperator::I32Rotr => sig!((I32, I32) -> (I32)),
+
+            WasmOperator::I64Add
+            | WasmOperator::I64Sub
+            | WasmOperator::I64Mul
+            | WasmOperator::I64DivS
+            | WasmOperator::I64DivU
+            | WasmOperator::I64RemS
+            | WasmOperator::I64RemU
+            | WasmOperator::I64And
+            | WasmOperator::I64Or
+            | WasmOperator::I64Xor
+            | WasmOperator::I64Shl
+            | WasmOperator::I64ShrS
+            | WasmOperator::I64ShrU
+            | WasmOperator::I64Rotl
+            | WasmOperator::I64Rotr => sig!((I64, I64) -> (I64)),
+
+            WasmOperator::F32Abs
+            | WasmOperator::F32Neg
+            | WasmOperator::F32Ceil
+            | WasmOperator::F32Floor
+            | WasmOperator::F32Trunc
+            | WasmOperator::F32Nearest
+            | WasmOperator::F32Sqrt => sig!((F32) -> (F32)),
+
+            WasmOperator::F64Abs
+            | WasmOperator::F64Neg
+            | WasmOperator::F64Ceil
+            | WasmOperator::F64Floor
+            | WasmOperator::F64Trunc
+            | WasmOperator::F64Nearest
+            | WasmOperator::F64Sqrt => sig!((F64) -> (F64)),
+
+            WasmOperator::F32Add
+            | WasmOperator::F32Sub
+            | WasmOperator::F32Mul
+            | WasmOperator::F32Div
+            | WasmOperator::F32Min
+            | WasmOperator::F32Max
+            | WasmOperator::F32Copysign => sig!((F32, F32) -> (F32)),
+
+            WasmOperator::F64Add
+            | WasmOperator::F64Sub
+            | WasmOperator::F64Mul
+            | WasmOperator::F64Div
+            | WasmOperator::F64Min
+            | WasmOperator::F64Max
+            | WasmOperator::F64Copysign => sig!((F64, F64) -> (F64)),
+
+            WasmOperator::I32WrapI64 => sig!((I64) -> (I32)),
+            WasmOperator::I32TruncSF32 | WasmOperator::I32TruncUF32 => sig!((F32) -> (I32)),
+            WasmOperator::I32TruncSF64 | WasmOperator::I32TruncUF64 => sig!((F64) -> (I32)),
+            WasmOperator::I64ExtendSI32 | WasmOperator::I64ExtendUI32 => sig!((I32) -> (I64)),
+            WasmOperator::I64TruncSF32 | WasmOperator::I64TruncUF32 => sig!((F32) -> (I64)),
+            WasmOperator::I64TruncSF64 | WasmOperator::I64TruncUF64 => sig!((F64) -> (I64)),
+            WasmOperator::F32ConvertSI32 | WasmOperator::F32ConvertUI32 => sig!((I32) -> (F32)),
+            WasmOperator::F32ConvertSI64 | WasmOperator::F32ConvertUI64 => sig!((I64) -> (F32)),
+            WasmOperator::F32DemoteF64 => sig!((F64) -> (F32)),
+            WasmOperator::F64ConvertSI32 | WasmOperator::F64ConvertUI32 => sig!((I32) -> (F64)),
+            WasmOperator::F64ConvertSI64 | WasmOperator::F64ConvertUI64 => sig!((I64) -> (F64)),
+            WasmOperator::F64PromoteF32 => sig!((F32) -> (F64)),
+            WasmOperator::I32ReinterpretF32 => sig!((F32) -> (I32)),
+            WasmOperator::I64ReinterpretF64 => sig!((F64) -> (I64)),
+            WasmOperator::F32ReinterpretI32 => sig!((I32) -> (F32)),
+            WasmOperator::F64ReinterpretI64 => sig!((I64) -> (F64)),
+
+            WasmOperator::I32Extend8S => sig!((I32) -> (I32)),
+            WasmOperator::I32Extend16S => sig!((I32) -> (I32)),
+            WasmOperator::I64Extend8S => sig!((I32) -> (I64)),
+            WasmOperator::I64Extend16S => sig!((I32) -> (I64)),
+            WasmOperator::I64Extend32S => sig!((I32) -> (I64)),
+
+            _ => unimplemented!(),
+        }
+    }
+
+    fn next_id(&mut self) -> u32 {
+        let id = self.current_id;
+        self.current_id += 1;
+        id
+    }
+
+    fn nth_block(&self, n: usize) -> &ControlFrame {
+        self.control_frames.iter().rev().nth(n).unwrap()
+    }
+
+    fn nth_block_mut(&mut self, n: usize) -> &mut ControlFrame {
+        self.control_frames.iter_mut().rev().nth(n).unwrap()
+    }
+
+    fn function_block(&self) -> &ControlFrame {
+        self.control_frames.first().unwrap()
+    }
+
+    fn local_depth(&self, idx: u32) -> u32 {
+        self.stack.len() as u32 - 1 - idx
+    }
+
+    fn apply_op(&mut self, sig: OpSig) {
+        let mut ty_param = None;
+
+        for p in sig.input.iter().rev() {
+            let stack_ty = self
+                .stack
+                .pop()
+                .unwrap_or_else(|| panic!("Stack is empty (while processing {:?})", sig));
+
+            let ty = match p {
+                SigT::T => {
+                    if let Some(t) = ty_param {
+                        t
+                    } else {
+                        ty_param = Some(stack_ty);
+                        stack_ty
+                    }
+                }
+                SigT::Concrete(ty) => *ty,
+            };
+
+            debug_assert_eq!(ty, stack_ty);
+        }
+
+        for p in sig.output.into_iter().rev() {
+            let ty = match p {
+                SigT::T => ty_param.expect("Type parameter was not set"),
+                SigT::Concrete(ty) => ty,
+            };
+            self.stack.push(ty);
+        }
+    }
+
+    fn block_params(&self) -> Vec<SignlessType> {
+        self.stack.clone()
+    }
+
+    fn block_params_with_wasm_type(&self, ty: wasmparser::Type) -> Vec<SignlessType> {
+        let mut out = self.block_params();
+        out.extend(Type::from_wasm(ty));
+        out
+    }
+
+    fn drop(&mut self, range: RangeInclusive<u32>) {
+        let internal_range = self.stack.len() - 1 - *range.end() as usize
+            ..=self.stack.len() - 1 - *range.start() as usize;
+
+        for _ in self.stack.drain(internal_range) {}
+    }
+}
+
+impl<'a, 'b, M: ModuleContext> Iterator for MicrowasmConv<'a, 'b, M>
+where
+    for<'any> &'any M::Signature: Into<OpSig>,
+{
+    type Item = wasmparser::Result<SmallVec<[OperatorFromWasm; 1]>>;
+
+    fn next(&mut self) -> Option<wasmparser::Result<SmallVec<[OperatorFromWasm; 1]>>> {
+        macro_rules! to_drop {
+            ($block:expr) => {{
+                let block = &$block;
+                let first_non_local_depth = block.returns;
+
+                (|| {
+                    let last_non_local_depth = (self.stack.len() as u32)
+                        .checked_sub(1)?
+                        .checked_sub(block.arguments)?;
+
+                    if first_non_local_depth <= last_non_local_depth {
+                        Some(first_non_local_depth..=last_non_local_depth)
+                    } else {
+                        None
+                    }
+                })()
+            }};
+        }
+
+        if self.is_done {
+            return None;
+        }
+
+        if let Some(consts) = self.consts_to_emit.take() {
+            return Some(Ok(consts
+                .into_iter()
+                .map(|value| Operator::Const(value))
+                .collect()));
+        }
+
+        if self.unreachable {
+            self.unreachable = false;
+            let mut depth = 0;
+
+            // `if..then..else`/`br_if` means that there may be branches in which
+            // the instruction that caused us to mark this as unreachable to not
+            // be executed. Tracking this in the microwasm translation step is
+            // very complicated so we just do basic code removal here and leave
+            // the removal of uncalled blocks to the backend.
+            return Some(Ok(loop {
+                let op = match self.internal.read() {
+                    Err(e) => return Some(Err(e)),
+                    Ok(o) => o,
+                };
+                match op {
+                    WasmOperator::Block { .. }
+                    | WasmOperator::Loop { .. }
+                    | WasmOperator::If { .. } => {
+                        depth += 1;
+                    }
+                    WasmOperator::Else => {
+                        if depth == 0 {
+                            let block = self.control_frames.last_mut().expect("Failed");
+
+                            self.stack = block.params().unwrap().to_vec();
+
+                            if let ControlFrameKind::If { has_else, .. } = &mut block.kind {
+                                *has_else = true;
+                            }
+
+                            break smallvec![Operator::Label((block.id, NameTag::Else))];
+                        }
+                    }
+                    WasmOperator::End => {
+                        if depth == 0 {
+                            let block = self.control_frames.pop().expect("Failed");
+
+                            if let Some(to_drop) = to_drop!(block) {
+                                self.drop(to_drop.clone());
+                            }
+
+                            if self.control_frames.is_empty() {
+                                self.is_done = true;
+                                return None;
+                            }
+
+                            let end_label = (block.id, NameTag::End);
+
+                            if let ControlFrameKind::If {
+                                has_else: false, ..
+                            } = block.kind
+                            {
+                                self.stack = block.params().unwrap().to_vec();
+
+                                break smallvec![
+                                    Operator::Label((block.id, NameTag::Else)),
+                                    Operator::Br {
+                                        target: BrTarget::Label(end_label),
+                                    },
+                                    Operator::Label(end_label),
+                                ];
+                            } else {
+                                break smallvec![Operator::Label((block.id, NameTag::End))];
+                            }
+                        } else {
+                            depth -= 1;
+                        }
+                    }
+                    _ => {}
+                }
+            }));
+        }
+
+        let op = match self.internal.read() {
+            Err(e) => return Some(Err(e)),
+            Ok(o) => o,
+        };
+
+        let op_sig = self.op_sig(&op);
+
+        self.apply_op(op_sig);
+
+        Some(Ok(match op {
+            WasmOperator::Unreachable => {
+                self.unreachable = true;
+                smallvec![Operator::Unreachable]
+            }
+            WasmOperator::Nop => smallvec![],
+            WasmOperator::Block { ty } => {
+                let id = self.next_id();
+                self.control_frames.push(ControlFrame {
+                    id,
+                    arguments: self.stack.len() as u32,
+                    returns: if ty == wasmparser::Type::EmptyBlockType {
+                        0
+                    } else {
+                        1
+                    },
+                    kind: ControlFrameKind::Block {
+                        needs_end_label: false,
+                    },
+                });
+                smallvec![Operator::end(
+                    self.block_params_with_wasm_type(ty),
+                    (id, NameTag::End),
+                )]
+            }
+            WasmOperator::Loop { ty } => {
+                let id = self.next_id();
+                self.control_frames.push(ControlFrame {
+                    id,
+                    arguments: self.stack.len() as u32,
+                    returns: if ty == wasmparser::Type::EmptyBlockType {
+                        0
+                    } else {
+                        1
+                    },
+                    kind: ControlFrameKind::Loop,
+                });
+                let label = (id, NameTag::Header);
+                smallvec![
+                    Operator::loop_(self.block_params(), label),
+                    Operator::end(self.block_params_with_wasm_type(ty), (id, NameTag::End)),
+                    Operator::Br {
+                        target: BrTarget::Label(label),
+                    },
+                    Operator::Label(label),
+                ]
+            }
+            WasmOperator::If { ty } => {
+                let id = self.next_id();
+                let params = self.block_params();
+                self.control_frames.push(ControlFrame {
+                    id,
+                    arguments: self.stack.len() as u32,
+                    returns: if ty == wasmparser::Type::EmptyBlockType {
+                        0
+                    } else {
+                        1
+                    },
+                    kind: ControlFrameKind::If {
+                        params,
+                        has_else: false,
+                    },
+                });
+                let (then, else_, end) = (
+                    (id, NameTag::Header),
+                    (id, NameTag::Else),
+                    (id, NameTag::End),
+                );
+                smallvec![
+                    Operator::block(self.block_params(), then),
+                    Operator::block(self.block_params(), else_),
+                    Operator::end(self.block_params_with_wasm_type(ty), end),
+                    Operator::BrIf {
+                        then: BrTarget::Label(then),
+                        else_: BrTarget::Label(else_),
+                    },
+                    Operator::Label(then),
+                ]
+            }
+            WasmOperator::Else => {
+                // We don't pop it since we're still in the second block.
+                let to_drop = to_drop!(self.control_frames.last().expect("Failed"));
+                let block = self.control_frames.last_mut().expect("Failed");
+
+                if let ControlFrameKind::If { has_else, .. } = &mut block.kind {
+                    *has_else = true;
+                }
+
+                self.stack = block.params().unwrap().to_vec();
+
+                let label = (block.id, NameTag::Else);
+
+                SmallVec::from_iter(
+                    to_drop
+                        .into_iter()
+                        .map(Operator::Drop)
+                        .chain(iter::once(Operator::Br {
+                            target: BrTarget::Label((block.id, NameTag::End)),
+                        }))
+                        .chain(iter::once(Operator::Label(label))),
+                )
+            }
+            WasmOperator::End => {
+                let block = self.control_frames.pop().expect("Failed");
+
+                let to_drop = to_drop!(block);
+
+                if let Some(to_drop) = &to_drop {
+                    self.drop(to_drop.clone());
+                }
+
+                if let ControlFrameKind::If {
+                    has_else: false, ..
+                } = block.kind
+                {
+                    let else_ = (block.id, NameTag::Else);
+                    let end = (block.id, NameTag::End);
+
+                    self.stack = block.params().unwrap().to_vec();
+
+                    to_drop
+                        .map(Operator::Drop)
+                        .into_iter()
+                        .chain::<SmallVec<[_; 4]>>(smallvec![
+                            Operator::Br {
+                                target: BrTarget::Label(else_),
+                            },
+                            Operator::Label(else_),
+                            Operator::Br {
+                                target: BrTarget::Label(end),
+                            },
+                            Operator::Label(end),
+                        ])
+                        .collect()
+                } else {
+                    SmallVec::from_iter(if self.control_frames.is_empty() {
+                        self.is_done = true;
+
+                        None.into_iter()
+                            .chain(Some(Operator::Br {
+                                target: BrTarget::Return,
+                            }))
+                            .chain(None)
+                    } else if block.needs_end_label() {
+                        let label = (block.id, NameTag::End);
+
+                        to_drop
+                            .map(Operator::Drop)
+                            .into_iter()
+                            .chain(Some(Operator::Br {
+                                target: BrTarget::Label(label),
+                            }))
+                            .chain(Some(Operator::Label(label)))
+                    } else {
+                        to_drop
+                            .map(Operator::Drop)
+                            .into_iter()
+                            .chain(None)
+                            .into_iter()
+                            .chain(None)
+                    })
+                }
+            }
+            // TODO: If we're breaking out of the function block we want
+            //       to drop locals too (see code for `WasmOperator::End`)
+            WasmOperator::Br { relative_depth } => {
+                self.unreachable = true;
+                let to_drop = to_drop!(self.nth_block(relative_depth as _));
+
+                let block = self.nth_block_mut(relative_depth as _);
+                block.mark_branched_to();
+                SmallVec::from_iter(to_drop.into_iter().map(Operator::Drop).chain(iter::once(
+                    Operator::Br {
+                        target: block.br_target(),
+                    },
+                )))
+            }
+            WasmOperator::BrIf { relative_depth } => {
+                let to_drop = to_drop!(self.nth_block(relative_depth as _));
+
+                let label = (self.next_id(), NameTag::Header);
+                let params = self.block_params();
+                let block = self.nth_block_mut(relative_depth as _);
+                block.mark_branched_to();
+
+                if let Some(_to_drop) = to_drop {
+                    // TODO: We want to generate an intermediate block here, but that might cause
+                    //       us to generate a spurious `jmp`.
+                    unimplemented!(
+                        "We don't yet support passing different numbers of arguments \
+                         to each half of a `br_if` - supporting this efficiently without \
+                         complicating the backend might be difficult"
+                    );
+                } else {
+                    smallvec![
+                        Operator::block(params, label),
+                        Operator::BrIf {
+                            then: block.br_target(),
+                            else_: BrTarget::Label(label),
+                        },
+                        Operator::Label(label),
+                    ]
+                }
+            }
+            WasmOperator::BrTable { table } => {
+                self.unreachable = true;
+                let (entries, default) = match table.read_table() {
+                    Ok(o) => o,
+                    Err(e) => return Some(Err(e)),
+                };
+                let targets = entries
+                    .into_iter()
+                    .map(|depth| {
+                        let block = self.nth_block_mut(*depth as _);
+                        block.mark_branched_to();
+                        block.br_target()
+                    })
+                    .collect();
+                let default = self.nth_block_mut(default as _);
+                default.mark_branched_to();
+                let default = default.br_target();
+
+                smallvec![Operator::BrTable(BrTable { targets, default })]
+            }
+            WasmOperator::Return => {
+                self.unreachable = true;
+
+                let block = self.function_block();
+                let to_drop = to_drop!(block);
+
+                SmallVec::from_iter(to_drop.into_iter().map(Operator::Drop).chain(iter::once(
+                    Operator::Br {
+                        target: block.br_target(),
+                    },
+                )))
+            }
+            WasmOperator::Call { function_index } => smallvec![Operator::Call { function_index }],
+            WasmOperator::CallIndirect { index, table_index } => {
+                smallvec![Operator::CallIndirect {
+                    type_index: index,
+                    table_index,
+                }]
+            }
+            WasmOperator::Drop => smallvec![Operator::Drop(0..=0)],
+            WasmOperator::Select => smallvec![Operator::Select],
+
+            WasmOperator::GetLocal { local_index } => {
+                // TODO: `- 1` because we apply the stack difference _before_ this point
+                let depth = self.local_depth(local_index) - 1;
+                smallvec![Operator::Pick { depth }]
+            }
+            WasmOperator::SetLocal { local_index } => {
+                // TODO: `+ 1` because we apply the stack difference _before_ this point
+                let depth = self.local_depth(local_index) + 1;
+                smallvec![Operator::Swap { depth }, Operator::Drop(0..=0)]
+            }
+            WasmOperator::TeeLocal { local_index } => {
+                let depth = self.local_depth(local_index);
+                smallvec![
+                    Operator::Swap { depth },
+                    Operator::Drop(0..=0),
+                    Operator::Pick { depth: depth - 1 },
+                ]
+            }
+
+            WasmOperator::I32Load { memarg } => smallvec![Operator::Load { ty: I32, memarg }],
+            WasmOperator::I64Load { memarg } => smallvec![Operator::Load { ty: I64, memarg }],
+            WasmOperator::F32Load { memarg } => smallvec![Operator::Load { ty: F32, memarg }],
+            WasmOperator::F64Load { memarg } => smallvec![Operator::Load { ty: F64, memarg }],
+            WasmOperator::I32Load8S { memarg } => smallvec![Operator::Load8 {
+                ty: sint::I32,
+                memarg,
+            }],
+            WasmOperator::I32Load8U { memarg } => smallvec![Operator::Load8 {
+                ty: sint::U32,
+                memarg,
+            }],
+            WasmOperator::I32Load16S { memarg } => smallvec![Operator::Load16 {
+                ty: sint::I32,
+                memarg,
+            }],
+            WasmOperator::I32Load16U { memarg } => smallvec![Operator::Load16 {
+                ty: sint::U32,
+                memarg,
+            }],
+            WasmOperator::I64Load8S { memarg } => smallvec![Operator::Load8 {
+                ty: sint::I64,
+                memarg,
+            }],
+            WasmOperator::I64Load8U { memarg } => smallvec![Operator::Load8 {
+                ty: sint::U64,
+                memarg,
+            }],
+            WasmOperator::I64Load16S { memarg } => smallvec![Operator::Load16 {
+                ty: sint::I64,
+                memarg,
+            }],
+            WasmOperator::I64Load16U { memarg } => smallvec![Operator::Load16 {
+                ty: sint::U64,
+                memarg,
+            }],
+            WasmOperator::I64Load32S { memarg } => smallvec![Operator::Load32 {
+                sign: Signedness::Signed,
+                memarg,
+            }],
+            WasmOperator::I64Load32U { memarg } => smallvec![Operator::Load32 {
+                sign: Signedness::Unsigned,
+                memarg,
+            }],
+
+            WasmOperator::I32Store { memarg } => smallvec![Operator::Store { ty: I32, memarg }],
+            WasmOperator::I64Store { memarg } => smallvec![Operator::Store { ty: I64, memarg }],
+            WasmOperator::F32Store { memarg } => smallvec![Operator::Store { ty: F32, memarg }],
+            WasmOperator::F64Store { memarg } => smallvec![Operator::Store { ty: F64, memarg }],
+
+            WasmOperator::I32Store8 { memarg } => smallvec![Operator::Store8 {
+                ty: Size::_32,
+                memarg,
+            }],
+            WasmOperator::I32Store16 { memarg } => smallvec![Operator::Store16 {
+                ty: Size::_32,
+                memarg,
+            }],
+            WasmOperator::I64Store8 { memarg } => smallvec![Operator::Store8 {
+                ty: Size::_64,
+                memarg,
+            }],
+            WasmOperator::I64Store16 { memarg } => smallvec![Operator::Store16 {
+                ty: Size::_64,
+                memarg,
+            }],
+            WasmOperator::I64Store32 { memarg } => smallvec![Operator::Store32 { memarg }],
+            WasmOperator::MemorySize { reserved } => smallvec![Operator::MemorySize { reserved }],
+            WasmOperator::MemoryGrow { reserved } => smallvec![Operator::MemoryGrow { reserved }],
+            WasmOperator::I32Const { value } => smallvec![Operator::Const(Value::I32(value))],
+            WasmOperator::I64Const { value } => smallvec![Operator::Const(Value::I64(value))],
+            WasmOperator::F32Const { value } => smallvec![Operator::Const(Value::F32(value))],
+            WasmOperator::F64Const { value } => smallvec![Operator::Const(Value::F64(value))],
+            WasmOperator::RefNull => unimplemented!("{:?}", op),
+            WasmOperator::RefIsNull => unimplemented!("{:?}", op),
+            WasmOperator::I32Eqz => smallvec![Operator::Eqz(Size::_32)],
+            WasmOperator::I32Eq => smallvec![Operator::Eq(I32)],
+            WasmOperator::I32Ne => smallvec![Operator::Ne(I32)],
+            WasmOperator::I32LtS => smallvec![Operator::Lt(SI32)],
+            WasmOperator::I32LtU => smallvec![Operator::Lt(SU32)],
+            WasmOperator::I32GtS => smallvec![Operator::Gt(SI32)],
+            WasmOperator::I32GtU => smallvec![Operator::Gt(SU32)],
+            WasmOperator::I32LeS => smallvec![Operator::Le(SI32)],
+            WasmOperator::I32LeU => smallvec![Operator::Le(SU32)],
+            WasmOperator::I32GeS => smallvec![Operator::Ge(SI32)],
+            WasmOperator::I32GeU => smallvec![Operator::Ge(SU32)],
+            WasmOperator::I64Eqz => smallvec![Operator::Eqz(Size::_64)],
+            WasmOperator::I64Eq => smallvec![Operator::Eq(I64)],
+            WasmOperator::I64Ne => smallvec![Operator::Ne(I64)],
+            WasmOperator::I64LtS => smallvec![Operator::Lt(SI64)],
+            WasmOperator::I64LtU => smallvec![Operator::Lt(SU64)],
+            WasmOperator::I64GtS => smallvec![Operator::Gt(SI64)],
+            WasmOperator::I64GtU => smallvec![Operator::Gt(SU64)],
+            WasmOperator::I64LeS => smallvec![Operator::Le(SI64)],
+            WasmOperator::I64LeU => smallvec![Operator::Le(SU64)],
+            WasmOperator::I64GeS => smallvec![Operator::Ge(SI64)],
+            WasmOperator::I64GeU => smallvec![Operator::Ge(SU64)],
+            WasmOperator::F32Eq => smallvec![Operator::Eq(F32)],
+            WasmOperator::F32Ne => smallvec![Operator::Ne(F32)],
+            WasmOperator::F32Lt => smallvec![Operator::Lt(SF32)],
+            WasmOperator::F32Gt => smallvec![Operator::Gt(SF32)],
+            WasmOperator::F32Le => smallvec![Operator::Le(SF32)],
+            WasmOperator::F32Ge => smallvec![Operator::Ge(SF32)],
+            WasmOperator::F64Eq => smallvec![Operator::Eq(F64)],
+            WasmOperator::F64Ne => smallvec![Operator::Ne(F64)],
+            WasmOperator::F64Lt => smallvec![Operator::Lt(SF64)],
+            WasmOperator::F64Gt => smallvec![Operator::Gt(SF64)],
+            WasmOperator::F64Le => smallvec![Operator::Le(SF64)],
+            WasmOperator::F64Ge => smallvec![Operator::Ge(SF64)],
+            WasmOperator::I32Clz => smallvec![Operator::Clz(Size::_32)],
+            WasmOperator::I32Ctz => smallvec![Operator::Ctz(Size::_32)],
+            WasmOperator::I32Popcnt => smallvec![Operator::Popcnt(Size::_32)],
+            WasmOperator::I32Add => smallvec![Operator::Add(I32)],
+            WasmOperator::I32Sub => smallvec![Operator::Sub(I32)],
+            WasmOperator::I32Mul => smallvec![Operator::Mul(I32)],
+            WasmOperator::I32DivS => smallvec![Operator::Div(SI32)],
+            WasmOperator::I32DivU => smallvec![Operator::Div(SU32)],
+            WasmOperator::I32RemS => smallvec![Operator::Rem(sint::I32)],
+            WasmOperator::I32RemU => smallvec![Operator::Rem(sint::U32)],
+            WasmOperator::I32And => smallvec![Operator::And(Size::_32)],
+            WasmOperator::I32Or => smallvec![Operator::Or(Size::_32)],
+            WasmOperator::I32Xor => smallvec![Operator::Xor(Size::_32)],
+            WasmOperator::I32Shl => smallvec![Operator::Shl(Size::_32)],
+            WasmOperator::I32ShrS => smallvec![Operator::Shr(sint::I32)],
+            WasmOperator::I32ShrU => smallvec![Operator::Shr(sint::U32)],
+            WasmOperator::I32Rotl => smallvec![Operator::Rotl(Size::_32)],
+            WasmOperator::I32Rotr => smallvec![Operator::Rotr(Size::_32)],
+            WasmOperator::I64Clz => smallvec![Operator::Clz(Size::_64)],
+            WasmOperator::I64Ctz => smallvec![Operator::Ctz(Size::_64)],
+            WasmOperator::I64Popcnt => smallvec![Operator::Popcnt(Size::_64)],
+            WasmOperator::I64Add => smallvec![Operator::Add(I64)],
+            WasmOperator::I64Sub => smallvec![Operator::Sub(I64)],
+            WasmOperator::I64Mul => smallvec![Operator::Mul(I64)],
+            WasmOperator::I64DivS => smallvec![Operator::Div(SI64)],
+            WasmOperator::I64DivU => smallvec![Operator::Div(SU64)],
+            WasmOperator::I64RemS => smallvec![Operator::Rem(sint::I64)],
+            WasmOperator::I64RemU => smallvec![Operator::Rem(sint::U64)],
+            WasmOperator::I64And => smallvec![Operator::And(Size::_64)],
+            WasmOperator::I64Or => smallvec![Operator::Or(Size::_64)],
+            WasmOperator::I64Xor => smallvec![Operator::Xor(Size::_64)],
+            WasmOperator::I64Shl => smallvec![Operator::Shl(Size::_64)],
+            WasmOperator::I64ShrS => smallvec![Operator::Shr(sint::I64)],
+            WasmOperator::I64ShrU => smallvec![Operator::Shr(sint::U64)],
+            WasmOperator::I64Rotl => smallvec![Operator::Rotl(Size::_64)],
+            WasmOperator::I64Rotr => smallvec![Operator::Rotr(Size::_64)],
+            WasmOperator::F32Abs => smallvec![Operator::Abs(Size::_32)],
+            WasmOperator::F32Neg => smallvec![Operator::Neg(Size::_32)],
+            WasmOperator::F32Ceil => smallvec![Operator::Ceil(Size::_32)],
+            WasmOperator::F32Floor => smallvec![Operator::Floor(Size::_32)],
+            WasmOperator::F32Trunc => smallvec![Operator::Trunc(Size::_32)],
+            WasmOperator::F32Nearest => smallvec![Operator::Nearest(Size::_32)],
+            WasmOperator::F32Sqrt => smallvec![Operator::Sqrt(Size::_32)],
+            WasmOperator::F32Add => smallvec![Operator::Add(F32)],
+            WasmOperator::F32Sub => smallvec![Operator::Sub(F32)],
+            WasmOperator::F32Mul => smallvec![Operator::Mul(F32)],
+            WasmOperator::F32Div => smallvec![Operator::Div(SF32)],
+            WasmOperator::F32Min => smallvec![Operator::Min(Size::_32)],
+            WasmOperator::F32Max => smallvec![Operator::Max(Size::_32)],
+            WasmOperator::F32Copysign => smallvec![Operator::Copysign(Size::_32)],
+            WasmOperator::F64Abs => smallvec![Operator::Abs(Size::_64)],
+            WasmOperator::F64Neg => smallvec![Operator::Neg(Size::_64)],
+            WasmOperator::F64Ceil => smallvec![Operator::Ceil(Size::_64)],
+            WasmOperator::F64Floor => smallvec![Operator::Floor(Size::_64)],
+            WasmOperator::F64Trunc => smallvec![Operator::Trunc(Size::_64)],
+            WasmOperator::F64Nearest => smallvec![Operator::Nearest(Size::_64)],
+            WasmOperator::F64Sqrt => smallvec![Operator::Sqrt(Size::_64)],
+            WasmOperator::F64Add => smallvec![Operator::Add(F64)],
+            WasmOperator::F64Sub => smallvec![Operator::Sub(F64)],
+            WasmOperator::F64Mul => smallvec![Operator::Mul(F64)],
+            WasmOperator::F64Div => smallvec![Operator::Div(SF64)],
+            WasmOperator::F64Min => smallvec![Operator::Min(Size::_64)],
+            WasmOperator::F64Max => smallvec![Operator::Max(Size::_64)],
+            WasmOperator::F64Copysign => smallvec![Operator::Copysign(Size::_64)],
+            WasmOperator::I32WrapI64 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncSF32 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncUF32 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncSF64 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncUF64 => unimplemented!("{:?}", op),
+            WasmOperator::I64ExtendSI32 => unimplemented!("{:?}", op),
+            WasmOperator::I64ExtendUI32 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncSF32 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncUF32 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncSF64 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncUF64 => unimplemented!("{:?}", op),
+            WasmOperator::F32ConvertSI32 => unimplemented!("{:?}", op),
+            WasmOperator::F32ConvertUI32 => unimplemented!("{:?}", op),
+            WasmOperator::F32ConvertSI64 => unimplemented!("{:?}", op),
+            WasmOperator::F32ConvertUI64 => unimplemented!("{:?}", op),
+            WasmOperator::F32DemoteF64 => unimplemented!("{:?}", op),
+            WasmOperator::F64ConvertSI32 => unimplemented!("{:?}", op),
+            WasmOperator::F64ConvertUI32 => unimplemented!("{:?}", op),
+            WasmOperator::F64ConvertSI64 => unimplemented!("{:?}", op),
+            WasmOperator::F64ConvertUI64 => unimplemented!("{:?}", op),
+            WasmOperator::F64PromoteF32 => unimplemented!("{:?}", op),
+            WasmOperator::I32ReinterpretF32 => unimplemented!("{:?}", op),
+            WasmOperator::I64ReinterpretF64 => unimplemented!("{:?}", op),
+            WasmOperator::F32ReinterpretI32 => unimplemented!("{:?}", op),
+            WasmOperator::F64ReinterpretI64 => unimplemented!("{:?}", op),
+            WasmOperator::I32Extend8S => unimplemented!("{:?}", op),
+            WasmOperator::I32Extend16S => unimplemented!("{:?}", op),
+            WasmOperator::I64Extend8S => unimplemented!("{:?}", op),
+            WasmOperator::I64Extend16S => unimplemented!("{:?}", op),
+            WasmOperator::I64Extend32S => unimplemented!("{:?}", op),
+
+            // 0xFC operators
+            // Non-trapping Float-to-int Conversions
+            WasmOperator::I32TruncSSatF32 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncUSatF32 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncSSatF64 => unimplemented!("{:?}", op),
+            WasmOperator::I32TruncUSatF64 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncSSatF32 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncUSatF32 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncSSatF64 => unimplemented!("{:?}", op),
+            WasmOperator::I64TruncUSatF64 => unimplemented!("{:?}", op),
+
+            other => unimplemented!("{:?}", other),
+        }))
+    }
+}
+
diff --git a/src/module.rs b/src/module.rs
index a38aac0940..de4ef2193f 100644
--- a/src/module.rs
+++ b/src/module.rs
@@ -1,34 +1,98 @@
+use crate::microwasm;
 use backend::TranslatedCodeSection;
+use cranelift_codegen::{
+    ir::{self, AbiParam, Signature as CraneliftSignature},
+    isa,
+};
 use error::Error;
-use std::mem;
+use std::{
+    convert::TryInto,
+    hash::{Hash, Hasher},
+    mem,
+};
 use translate_sections;
-use wasmparser::{FuncType, ModuleReader, SectionCode};
+use wasmparser::{FuncType, MemoryType, ModuleReader, SectionCode, TableType, Type};
 
-pub trait FunctionArgs {
-    unsafe fn call<T>(self, start: *const u8) -> T;
+pub trait AsValueType {
+    const TYPE: Type;
 }
 
+pub trait TypeList {
+    const TYPE_LIST: &'static [Type];
+}
+
+impl<T> TypeList for T
+where
+    T: AsValueType,
+{
+    const TYPE_LIST: &'static [Type] = &[T::TYPE];
+}
+
+impl AsValueType for i32 {
+    const TYPE: Type = Type::I32;
+}
+impl AsValueType for i64 {
+    const TYPE: Type = Type::I64;
+}
+impl AsValueType for u32 {
+    const TYPE: Type = Type::I32;
+}
+impl AsValueType for u64 {
+    const TYPE: Type = Type::I64;
+}
+impl AsValueType for f32 {
+    const TYPE: Type = Type::F32;
+}
+impl AsValueType for f64 {
+    const TYPE: Type = Type::F64;
+}
+
+pub trait FunctionArgs<O> {
+    type FuncType;
+
+    unsafe fn call(self, func: Self::FuncType, vm_ctx: *const u8) -> O;
+    fn into_func(start: *const u8) -> Self::FuncType;
+}
+
+type VmCtxPtr = u64;
+
 macro_rules! impl_function_args {
     ($first:ident $(, $rest:ident)*) => {
-        impl<$first, $($rest),*> FunctionArgs for ($first, $($rest),*) {
+        impl<Output, $first, $($rest),*> FunctionArgs<Output> for ($first, $($rest),*) {
+            type FuncType = unsafe extern "sysv64" fn(VmCtxPtr, $first $(, $rest)*) -> Output;
+
             #[allow(non_snake_case)]
-            unsafe fn call<T>(self, start: *const u8) -> T {
-                let func = mem::transmute::<_, extern "sysv64" fn($first, $($rest),*) -> T>(start);
-                {
-                    let ($first, $($rest),*) = self;
-                    func($first, $($rest),*)
-                }
+            unsafe fn call(self, func: Self::FuncType, vm_ctx: *const u8) -> Output {
+                let ($first, $($rest),*) = self;
+                func(vm_ctx as VmCtxPtr, $first $(, $rest)*)
             }
+
+            fn into_func(start: *const u8) -> Self::FuncType {
+                unsafe { mem::transmute(start) }
+            }
+        }
+
+        impl<$first: AsValueType, $($rest: AsValueType),*> TypeList for ($first, $($rest),*) {
+            const TYPE_LIST: &'static [Type] = &[$first::TYPE, $($rest::TYPE),*];
         }
 
         impl_function_args!($($rest),*);
     };
     () => {
-        impl FunctionArgs for () {
-            unsafe fn call<T>(self, start: *const u8) -> T {
-                let func = mem::transmute::<_, extern "sysv64" fn() -> T>(start);
-                func()
+        impl<Output> FunctionArgs<Output> for () {
+            type FuncType = unsafe extern "sysv64" fn(VmCtxPtr) -> Output;
+
+            unsafe fn call(self, func: Self::FuncType, vm_ctx: *const u8) -> Output {
+                func(vm_ctx as VmCtxPtr)
             }
+
+            fn into_func(start: *const u8) -> Self::FuncType {
+                unsafe { mem::transmute(start) }
+            }
+        }
+
+        impl TypeList for () {
+            const TYPE_LIST: &'static [Type] = &[];
         }
     };
 }
@@ -38,42 +102,374 @@ impl_function_args!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S);
 #[derive(Default)]
 pub struct TranslatedModule {
     translated_code_section: Option<TranslatedCodeSection>,
+    types: SimpleContext,
+    // TODO: Should we wrap this in a `Mutex` so that calling functions from multiple
+    //       threads doesn't cause data races?
+    table: Option<(TableType, Vec<u32>)>,
+    memory: Option<MemoryType>,
+}
+
+pub fn quickhash<H: Hash>(h: H) -> u64 {
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    h.hash(&mut hasher);
+    hasher.finish()
 }
 
 impl TranslatedModule {
-    // For testing only.
-    // TODO: Handle generic signatures.
-    pub unsafe fn execute_func<Args: FunctionArgs, T>(&self, func_idx: u32, args: Args) -> T {
+    pub fn instantiate(mut self) -> ExecutableModule {
+        let table = {
+            let code_section = self
+                .translated_code_section
+                .as_ref()
+                .expect("We don't currently support a table section without a code section");
+            let types = &self.types;
+
+            self.table
+                .as_mut()
+                .map(|&mut (_, ref mut idxs)| {
+                    let initial = idxs
+                        .iter()
+                        .map(|i| {
+                            let start = code_section.func_start(*i as _);
+                            let ty = types.func_type(*i);
+
+                            RuntimeFunc {
+                                func_start: start,
+                                sig_hash: quickhash(ty) as u32,
+                            }
+                        })
+                        .collect::<Vec<_>>();
+                    let out = BoxSlice::from(initial.into_boxed_slice());
+                    out
+                })
+                .unwrap_or(BoxSlice {
+                    ptr: std::ptr::NonNull::dangling().as_ptr(),
+                    len: 0,
+                })
+        };
+
+        let mem_size = self.memory.map(|m| m.limits.initial).unwrap_or(0) as usize;
+        let mem: BoxSlice<_> = vec![0u8; mem_size * WASM_PAGE_SIZE]
+            .into_boxed_slice()
+            .into();
+
+        let ctx = if mem.len > 0 || table.len > 0 {
+            Some(Box::new(VmCtx { table, mem }))
+        } else {
+            None
+        };
+
+        ExecutableModule {
+            module: self,
+            context: ctx,
+        }
+    }
+
+    pub fn disassemble(&self) {
+        self.translated_code_section
+            .as_ref()
+            .expect("no code section")
+            .disassemble();
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ExecutionError {
+    FuncIndexOutOfBounds,
+    TypeMismatch,
+}
+
+pub struct ExecutableModule {
+    module: TranslatedModule,
+    context: Option<Box<VmCtx>>,
+}
+
+impl ExecutableModule {
+    /// Executes the function _without checking types_. This can cause undefined
+    /// memory to be accessed.
+    pub unsafe fn execute_func_unchecked<Args: FunctionArgs<T>, T>(
+        &self,
+        func_idx: u32,
+        args: Args,
+    ) -> T {
         let code_section = self
+            .module
             .translated_code_section
             .as_ref()
             .expect("no code section");
         let start_buf = code_section.func_start(func_idx as usize);
 
-        args.call(start_buf)
+        args.call(
+            Args::into_func(start_buf),
+            self.context
+                .as_ref()
+                .map(|ctx| (&**ctx) as *const VmCtx as *const u8)
+                .unwrap_or(std::ptr::null()),
+        )
+    }
+
+    pub fn execute_func<Args: FunctionArgs<T> + TypeList, T: TypeList>(
+        &self,
+        func_idx: u32,
+        args: Args,
+    ) -> Result<T, ExecutionError> {
+        let module = &self.module;
+
+        if func_idx as usize >= module.types.func_ty_indicies.len() {
+            return Err(ExecutionError::FuncIndexOutOfBounds);
+        }
+
+        let type_ = module.types.func_type(func_idx);
+
+        // TODO: Handle "compatible" types (i.e. f32 and i32)
+        if (&type_.params[..], &type_.returns[..]) != (Args::TYPE_LIST, T::TYPE_LIST) {
+            return Err(ExecutionError::TypeMismatch);
+        }
+
+        Ok(unsafe { self.execute_func_unchecked(func_idx, args) })
+    }
+
+    pub fn disassemble(&self) {
+        self.module.disassemble();
     }
 }
 
-#[derive(Default)]
-pub struct TranslationContext {
+type FuncRef = *const u8;
+
+pub struct RuntimeFunc {
+    sig_hash: u32,
+    func_start: FuncRef,
+}
+
+unsafe impl Send for RuntimeFunc {}
+unsafe impl Sync for RuntimeFunc {}
+
+impl RuntimeFunc {
+    pub fn offset_of_sig_hash() -> usize {
+        offset_of!(Self, sig_hash)
+    }
+
+    pub fn offset_of_func_start() -> usize {
+        offset_of!(Self, func_start)
+    }
+}
+
+struct BoxSlice<T> {
+    len: usize,
+    ptr: *mut T,
+}
+
+impl<T> From<Box<[T]>> for BoxSlice<T> {
+    fn from(mut other: Box<[T]>) -> Self {
+        let out = BoxSlice {
+            len: other.len(),
+            ptr: other.as_mut_ptr(),
+        };
+        mem::forget(other);
+        out
+    }
+}
+
+unsafe impl<T: Send> Send for BoxSlice<T> {}
+unsafe impl<T: Sync> Sync for BoxSlice<T> {}
+
+impl<T> Drop for BoxSlice<T> {
+    fn drop(&mut self) {
+        unsafe { Vec::from_raw_parts(self.ptr, self.len, self.len) };
+    }
+}
+
+pub struct VmCtx {
+    table: BoxSlice<RuntimeFunc>,
+    mem: BoxSlice<u8>,
+}
+
+impl VmCtx {
+    pub fn offset_of_memory_ptr() -> u8 {
+        offset_of!(Self, mem.ptr)
+            .try_into()
+            .expect("Offset exceeded size of u8")
+    }
+
+    pub fn offset_of_memory_len() -> u8 {
+        offset_of!(Self, mem.len)
+            .try_into()
+            .expect("Offset exceeded size of u8")
+    }
+
+    pub fn offset_of_funcs_ptr() -> u8 {
+        offset_of!(Self, table.ptr)
+            .try_into()
+            .expect("Offset exceeded size of u8")
+    }
+
+    pub fn offset_of_funcs_len() -> u8 {
+        offset_of!(Self, table.len)
+            .try_into()
+            .expect("Offset exceeded size of u8")
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct SimpleContext {
     types: Vec<FuncType>,
     func_ty_indicies: Vec<u32>,
 }
 
-impl TranslationContext {
-    pub fn func_type(&self, func_idx: u32) -> &FuncType {
-        // TODO: This assumes that there is no imported functions.
-        let func_ty_idx = self.func_ty_indicies[func_idx as usize];
-        &self.types[func_ty_idx as usize]
+const WASM_PAGE_SIZE: usize = 65_536;
+
+pub trait Signature {
+    type Type: SigType;
+
+    fn params(&self) -> &[Self::Type];
+    fn returns(&self) -> &[Self::Type];
+}
+
+pub trait SigType {
+    fn to_microwasm_type(&self) -> microwasm::SignlessType;
+    fn is_float(&self) -> bool;
+}
+
+impl SigType for AbiParam {
+    fn to_microwasm_type(&self) -> microwasm::SignlessType {
+        use microwasm::{Size::*, Type::*};
+
+        if self.value_type.is_int() {
+            match self.value_type.bits() {
+                32 => Int(_32),
+                64 => Int(_64),
+                _ => unimplemented!(),
+            }
+        } else if self.value_type.is_float() {
+            match self.value_type.bits() {
+                32 => Float(_32),
+                64 => Float(_64),
+                _ => unimplemented!(),
+            }
+        } else {
+            unimplemented!()
+        }
+    }
+
+    fn is_float(&self) -> bool {
+        self.value_type.is_float()
+    }
+}
+
+impl Signature for CraneliftSignature {
+    type Type = AbiParam;
+
+    fn params(&self) -> &[Self::Type] {
+        // TODO: We want to instead add the `VMContext` to the signature used by
+        //       cranelift, removing the special-casing from the internals.
+        assert_eq!(self.params[0].purpose, ir::ArgumentPurpose::VMContext);
+        assert_eq!(self.call_conv, isa::CallConv::SystemV);
+        &self.params[1..]
+    }
+
+    fn returns(&self) -> &[Self::Type] {
+        assert_eq!(self.call_conv, isa::CallConv::SystemV);
+        &self.returns
+    }
+}
+
+impl SigType for wasmparser::Type {
+    fn to_microwasm_type(&self) -> microwasm::SignlessType {
+        microwasm::Type::from_wasm(*self).unwrap()
+    }
+
+    fn is_float(&self) -> bool {
+        match self {
+            wasmparser::Type::F32 | wasmparser::Type::F64 => true,
+            _ => false,
+        }
+    }
+}
+
+impl Signature for FuncType {
+    type Type = wasmparser::Type;
+
+    fn params(&self) -> &[Self::Type] {
+        &*self.params
+    }
+
+    fn returns(&self) -> &[Self::Type] {
+        &*self.returns
+    }
+}
+
+pub trait ModuleContext {
+    type Signature: Signature + Hash;
+
+    fn func_type_index(&self, func_idx: u32) -> u32;
+    fn signature(&self, index: u32) -> &Self::Signature;
+    fn offset_of_memory_ptr(&self) -> u8;
+    fn offset_of_memory_len(&self) -> u8;
+    fn offset_of_funcs_ptr(&self) -> u8;
+    fn offset_of_funcs_len(&self) -> u8;
+
+    fn func_index(&self, defined_func_index: u32) -> u32;
+    fn defined_func_index(&self, func_index: u32) -> Option<u32>;
+
+    fn defined_func_type(&self, func_idx: u32) -> &Self::Signature {
+        // TODO: This assumes that there are no imported functions.
+        self.func_type(self.func_index(func_idx))
+    }
+
+    fn func_type(&self, func_idx: u32) -> &Self::Signature {
+        // TODO: This assumes that there are no imported functions.
+        self.signature(self.func_type_index(func_idx))
+    }
+}
+
+impl ModuleContext for SimpleContext {
+    type Signature = FuncType;
+
+    // TODO: We don't support external functions yet
+    fn func_index(&self, func_idx: u32) -> u32 {
+        func_idx
+    }
+
+    fn defined_func_index(&self, func_idx: u32) -> Option<u32> {
+        Some(func_idx)
+    }
+
+    fn func_type_index(&self, func_idx: u32) -> u32 {
+        self.func_ty_indicies[func_idx as usize]
+    }
+
+    fn signature(&self, index: u32) -> &Self::Signature {
+        &self.types[index as usize]
+    }
+
+    fn offset_of_memory_ptr(&self) -> u8 {
+        VmCtx::offset_of_memory_ptr()
+    }
+
+    fn offset_of_memory_len(&self) -> u8 {
+        VmCtx::offset_of_memory_len()
+    }
+
+    fn offset_of_funcs_ptr(&self) -> u8 {
+        VmCtx::offset_of_funcs_ptr()
+    }
+
+    fn offset_of_funcs_len(&self) -> u8 {
+        VmCtx::offset_of_funcs_len()
     }
 
     // TODO: type of a global
 }
 
+pub fn translate(data: &[u8]) -> Result<ExecutableModule, Error> {
+    translate_only(data).map(|m| m.instantiate())
+}
+
 /// Translate from a slice of bytes holding a wasm module.
-pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
+pub fn translate_only(data: &[u8]) -> Result<TranslatedModule, Error> {
     let mut reader = ModuleReader::new(data)?;
     let mut output = TranslatedModule::default();
+    let mut table = None;
 
     reader.skip_custom_sections()?;
     if reader.eof() {
@@ -81,11 +477,9 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
     }
     let mut section = reader.read()?;
 
-    let mut ctx = TranslationContext::default();
-
     if let SectionCode::Type = section.code {
         let types_reader = section.get_type_section_reader()?;
-        ctx.types = translate_sections::type_(types_reader)?;
+        output.types.types = translate_sections::type_(types_reader)?;
 
         reader.skip_custom_sections()?;
         if reader.eof() {
@@ -107,7 +501,7 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
 
     if let SectionCode::Function = section.code {
         let functions = section.get_function_section_reader()?;
-        ctx.func_ty_indicies = translate_sections::function(functions)?;
+        output.types.func_ty_indicies = translate_sections::function(functions)?;
 
         reader.skip_custom_sections()?;
         if reader.eof() {
@@ -118,7 +512,11 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
 
     if let SectionCode::Table = section.code {
         let tables = section.get_table_section_reader()?;
-        translate_sections::table(tables)?;
+        let mut tables = translate_sections::table(tables)?;
+
+        assert!(tables.len() <= 1);
+
+        table = tables.drain(..).next();
 
         reader.skip_custom_sections()?;
         if reader.eof() {
@@ -129,7 +527,18 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
 
     if let SectionCode::Memory = section.code {
         let memories = section.get_memory_section_reader()?;
-        translate_sections::memory(memories)?;
+        let mem = translate_sections::memory(memories)?;
+
+        assert!(
+            mem.len() <= 1,
+            "Multiple memory sections not yet unimplemented"
+        );
+
+        if !mem.is_empty() {
+            let mem = mem[0];
+            assert_eq!(Some(mem.limits.initial), mem.limits.maximum);
+            output.memory = Some(mem);
+        }
 
         reader.skip_custom_sections()?;
         if reader.eof() {
@@ -173,7 +582,12 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
 
     if let SectionCode::Element = section.code {
         let elements = section.get_element_section_reader()?;
-        translate_sections::element(elements)?;
+        let elements = translate_sections::element(elements)?;
+
+        output.table = Some((
+            table.expect("Element section with no table section"),
+            elements,
+        ));
 
         reader.skip_custom_sections()?;
         if reader.eof() {
@@ -184,7 +598,7 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
 
     if let SectionCode::Code = section.code {
         let code = section.get_code_section_reader()?;
-        output.translated_code_section = Some(translate_sections::code(code, &ctx)?);
+        output.translated_code_section = Some(translate_sections::code(code, &output.types)?);
 
         reader.skip_custom_sections()?;
         if reader.eof() {
@@ -198,5 +612,7 @@ pub fn translate(data: &[u8]) -> Result<TranslatedModule, Error> {
         translate_sections::data(data)?;
     }
 
+    assert!(reader.eof());
+
     Ok(output)
 }
diff --git a/src/tests.rs b/src/tests.rs
index 0e434c7233..5abf11ab12 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -1,7 +1,7 @@
-use super::{translate, TranslatedModule};
+use super::{module::ExecutionError, translate, ExecutableModule};
 use wabt;
 
-fn translate_wat(wat: &str) -> TranslatedModule {
+fn translate_wat(wat: &str) -> ExecutableModule {
     let wasm = wabt::wat2wasm(wat).unwrap();
     let compiled = translate(&wasm).unwrap();
     compiled
@@ -10,7 +10,8 @@ fn translate_wat(wat: &str) -> TranslatedModule {
 /// Execute the first function in the module.
 fn execute_wat(wat: &str, a: u32, b: u32) -> u32 {
     let translated = translate_wat(wat);
-    unsafe { translated.execute_func(0, (a, b)) }
+    translated.disassemble();
+    translated.execute_func(0, (a, b)).unwrap()
 }
 
 #[test]
@@ -18,54 +19,512 @@ fn empty() {
     let _ = translate_wat("(module (func))");
 }
 
-#[test]
-fn adds() {
-    const CASES: &[(u32, u32, u32)] = &[(5, 3, 8), (0, 228, 228), (u32::max_value(), 1, 0)];
+mod op32 {
+    use super::{translate_wat, ExecutableModule};
 
-    let code = r#"
-(module
-  (func (param i32) (param i32) (result i32) (i32.add (get_local 0) (get_local 1)))
-)
-    "#;
-    for (a, b, expected) in CASES {
-        assert_eq!(execute_wat(code, *a, *b), *expected);
+    macro_rules! binop_test {
+        ($op:ident, $func:expr) => {
+            mod $op {
+                use super::{translate_wat, ExecutableModule};
+                use std::sync::Once;
+
+                const OP: &str = stringify!($op);
+
+                lazy_static! {
+                    static ref AS_PARAMS: ExecutableModule = translate_wat(&format!(
+                        "(module (func (param i32) (param i32) (result i32)
+                            (i32.{op} (get_local 0) (get_local 1))))",
+                        op = OP
+                    ));
+                }
+
+                quickcheck! {
+                    fn as_params(a: i32, b: i32) -> bool {
+                         AS_PARAMS.execute_func::<(i32, i32), i32>(0, (a, b)) == Ok($func(a, b))
+                    }
+
+                    fn lit_lit(a: i32, b: i32) -> bool {
+                        let translated = translate_wat(&format!("
+                            (module (func (result i32)
+                                (i32.{op} (i32.const {left}) (i32.const {right}))))
+                        ", op = OP, left = a, right = b));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(), i32>(0, ()) == Ok($func(a, b))
+                    }
+
+                    fn lit_reg(a: i32, b: i32) -> bool {
+                                                let translated = translate_wat(&format!("
+                            (module (func (param i32) (result i32)
+                                (i32.{op} (i32.const {left}) (get_local 0))))
+                        ", op = OP, left = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(i32,), i32>(0, (b,)) == Ok($func(a, b))
+                    }
+
+                    fn reg_lit(a: i32, b: i32) -> bool {
+                                                let translated = translate_wat(&format!("
+                            (module (func (param i32) (result i32)
+                                (i32.{op} (get_local 0) (i32.const {right}))))
+                        ", op = OP, right = b));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(i32,), i32>(0, (a,)) == Ok($func(a, b))
+                    }
+                }
+            }
+        };
     }
+
+    macro_rules! unop_test {
+        ($name:ident, $func:expr) => {
+            mod $name {
+                use super::{translate_wat, ExecutableModule};
+                use std::sync::Once;
+
+                lazy_static! {
+                    static ref AS_PARAM: ExecutableModule = translate_wat(concat!(
+                        "(module (func (param i32) (result i32)
+                            (i32.",
+                        stringify!($name),
+                        " (get_local 0))))"
+                    ),);
+                }
+
+                quickcheck! {
+                    fn as_param(a: u32) -> bool {
+                         AS_PARAM.execute_func::<(u32,), u32>(0, (a,)) == Ok($func(a))
+                    }
+
+                    fn lit(a: u32) -> bool {
+                                                let translated = translate_wat(&format!(concat!("
+                            (module (func (result i32)
+                                (i32.",stringify!($name)," (i32.const {val}))))
+                        "), val = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(), u32>(0, ()) == Ok($func(a))
+                    }
+                }
+            }
+        };
+    }
+
+    unop_test!(clz, u32::leading_zeros);
+    unop_test!(ctz, u32::trailing_zeros);
+    unop_test!(popcnt, u32::count_ones);
+    unop_test!(eqz, |a: u32| if a == 0 { 1 } else { 0 });
+
+    binop_test!(add, i32::wrapping_add);
+    binop_test!(sub, i32::wrapping_sub);
+    binop_test!(and, std::ops::BitAnd::bitand);
+    binop_test!(or, std::ops::BitOr::bitor);
+    binop_test!(xor, std::ops::BitXor::bitxor);
+    binop_test!(mul, i32::wrapping_mul);
+    binop_test!(eq, |a, b| if a == b { 1 } else { 0 });
+    binop_test!(ne, |a, b| if a != b { 1 } else { 0 });
+    binop_test!(lt_u, |a, b| if (a as u32) < (b as u32) { 1 } else { 0 });
+    binop_test!(le_u, |a, b| if (a as u32) <= (b as u32) { 1 } else { 0 });
+    binop_test!(gt_u, |a, b| if (a as u32) > (b as u32) { 1 } else { 0 });
+    binop_test!(ge_u, |a, b| if (a as u32) >= (b as u32) { 1 } else { 0 });
+    binop_test!(lt_s, |a, b| if a < b { 1 } else { 0 });
+    binop_test!(le_s, |a, b| if a <= b { 1 } else { 0 });
+    binop_test!(gt_s, |a, b| if a > b { 1 } else { 0 });
+    binop_test!(ge_s, |a, b| if a >= b { 1 } else { 0 });
+    binop_test!(shl, |a, b| (a as i32).wrapping_shl(b as _));
+    binop_test!(shr_s, |a, b| (a as i32).wrapping_shr(b as _));
+    binop_test!(shr_u, |a, b| (a as u32).wrapping_shr(b as _) as i32);
+    binop_test!(rotl, |a, b| (a as u32).rotate_left(b as _) as i32);
+    binop_test!(rotr, |a, b| (a as u32).rotate_right(b as _) as i32);
 }
 
-#[test]
-fn relop_eq() {
-    const CASES: &[(u32, u32, u32)] = &[
-        (0, 0, 1),
-        (0, 1, 0),
-        (1, 0, 0),
-        (1, 1, 1),
-        (1312, 1, 0),
-        (1312, 1312, 1),
-    ];
+mod op64 {
+    use super::{translate_wat, ExecutableModule};
 
-    let code = r#"
-(module
-  (func (param i32) (param i32) (result i32) (i32.eq (get_local 0) (get_local 1)))
-)
-    "#;
+    macro_rules! binop_test {
+        ($op:ident, $func:expr) => {
+            binop_test!($op, $func, i64);
+        };
+        ($op:ident, $func:expr, $retty:ident) => {
+            mod $op {
+                use super::{translate_wat, ExecutableModule};
 
-    for (a, b, expected) in CASES {
-        assert_eq!(execute_wat(code, *a, *b), *expected);
+                const RETTY: &str = stringify!($retty);
+                const OP: &str = stringify!($op);
+
+                lazy_static! {
+                    static ref AS_PARAMS: ExecutableModule = translate_wat(&format!("
+                        (module (func (param i64) (param i64) (result {retty})
+                            (i64.{op} (get_local 0) (get_local 1))))
+                    ", retty = RETTY, op = OP));
+                }
+
+                quickcheck! {
+                    fn as_params(a: i64, b: i64) -> bool {
+                        AS_PARAMS.execute_func::<(i64, i64), $retty>(0, (a, b)) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn lit_lit(a: i64, b: i64) -> bool {
+                        translate_wat(&format!("
+                            (module (func (result {retty})
+                                (i64.{op} (i64.const {left}) (i64.const {right}))))
+                        ", retty = RETTY, op = OP, left = a, right = b)).execute_func::<(), $retty>(0, ()) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn lit_reg(a: i64, b: i64) -> bool {
+                        use std::sync::Once;
+
+                        let translated = translate_wat(&format!("
+                            (module (func (param i64) (result {retty})
+                                (i64.{op} (i64.const {left}) (get_local 0))))
+                        ", retty = RETTY, op = OP, left = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(i64,), $retty>(0, (b,)) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn reg_lit(a: i64, b: i64) -> bool {
+                        use std::sync::Once;
+
+                        let translated = translate_wat(&format!("
+                            (module (func (param i64) (result {retty})
+                                (i64.{op} (get_local 0) (i64.const {right}))))
+                        ", retty = RETTY, op = OP, right = b));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(i64,), $retty>(0, (a,)) == Ok($func(a, b) as $retty)
+                    }
+                }
+            }
+        };
     }
+
+    macro_rules! unop_test {
+        ($name:ident, $func:expr) => {
+            unop_test!($name, $func, i64);
+        };
+        ($name:ident, $func:expr, $out_ty:ty) => {
+            mod $name {
+                use super::{translate_wat, ExecutableModule};
+                use std::sync::Once;
+
+                lazy_static! {
+                    static ref AS_PARAM: ExecutableModule = translate_wat(concat!(
+                        "(module (func (param i64) (result ",
+                        stringify!($out_ty),
+                        ")
+                            (i64.",
+                        stringify!($name),
+                        " (get_local 0))))"
+                    ),);
+                }
+
+                quickcheck! {
+                    fn as_param(a: u64) -> bool {
+                         AS_PARAM.execute_func::<(u64,), $out_ty>(0, (a,)) == Ok($func(a))
+                    }
+
+                    fn lit(a: u64) -> bool {
+                                                let translated = translate_wat(&format!(concat!("
+                            (module (func (result ",stringify!($out_ty),")
+                                (i64.",stringify!($name)," (i64.const {val}))))
+                        "), val = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(), $out_ty>(0, ()) == Ok($func(a))
+                    }
+                }
+            }
+        };
+    }
+
+    unop_test!(clz, |a: u64| a.leading_zeros() as _);
+    unop_test!(ctz, |a: u64| a.trailing_zeros() as _);
+    unop_test!(popcnt, |a: u64| a.count_ones() as _);
+    unop_test!(eqz, |a: u64| if a == 0 { 1 } else { 0 }, i32);
+
+    binop_test!(add, i64::wrapping_add);
+    binop_test!(sub, i64::wrapping_sub);
+    binop_test!(and, std::ops::BitAnd::bitand);
+    binop_test!(or, std::ops::BitOr::bitor);
+    binop_test!(xor, std::ops::BitXor::bitxor);
+    binop_test!(mul, i64::wrapping_mul);
+    binop_test!(eq, |a, b| if a == b { 1 } else { 0 }, i32);
+    binop_test!(ne, |a, b| if a != b { 1 } else { 0 }, i32);
+    binop_test!(
+        lt_u,
+        |a, b| if (a as u64) < (b as u64) { 1 } else { 0 },
+        i32
+    );
+    binop_test!(
+        le_u,
+        |a, b| if (a as u64) <= (b as u64) { 1 } else { 0 },
+        i32
+    );
+    binop_test!(
+        gt_u,
+        |a, b| if (a as u64) > (b as u64) { 1 } else { 0 },
+        i32
+    );
+    binop_test!(
+        ge_u,
+        |a, b| if (a as u64) >= (b as u64) { 1 } else { 0 },
+        i32
+    );
+    binop_test!(lt_s, |a, b| if a < b { 1 } else { 0 }, i32);
+    binop_test!(le_s, |a, b| if a <= b { 1 } else { 0 }, i32);
+    binop_test!(gt_s, |a, b| if a > b { 1 } else { 0 }, i32);
+    binop_test!(ge_s, |a, b| if a >= b { 1 } else { 0 }, i32);
+    binop_test!(shl, |a, b| (a as i64).wrapping_shl(b as _));
+    binop_test!(shr_s, |a, b| (a as i64).wrapping_shr(b as _));
+    binop_test!(shr_u, |a, b| (a as u64).wrapping_shr(b as _) as i64);
+    binop_test!(rotl, |a, b| (a as u64).rotate_left(b as _) as i64);
+    binop_test!(rotr, |a, b| (a as u64).rotate_right(b as _) as i64);
 }
 
-#[test]
-fn if_then_else() {
-    const CASES: &[(u32, u32, u32)] = &[
-        (0, 1, 1),
-        (0, 0, 0),
-        (1, 0, 0),
-        (1, 1, 1),
-        (1312, 1, 1),
-        (1312, 1312, 1312),
-    ];
+mod opf32 {
+    use super::{translate_wat, ExecutableModule};
 
-    let code = r#"
+    macro_rules! binop_test {
+        ($op:ident, $func:expr) => {
+            binop_test!($op, $func, f32);
+        };
+        ($op:ident, $func:expr, $retty:ident) => {
+            mod $op {
+                use super::{translate_wat, ExecutableModule};
+
+                const RETTY: &str = stringify!($retty);
+                const OP: &str = stringify!($op);
+
+                lazy_static! {
+                    static ref AS_PARAMS: ExecutableModule = translate_wat(&format!("
+                        (module (func (param f32) (param f32) (result {retty})
+                            (f32.{op} (get_local 0) (get_local 1))))
+                    ", retty = RETTY, op = OP));
+                }
+
+                quickcheck! {
+                    fn as_params(a: f32, b: f32) -> bool {
+                        AS_PARAMS.execute_func::<(f32, f32), $retty>(0, (a, b)) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn lit_lit(a: f32, b: f32) -> bool {
+                        translate_wat(&format!("
+                            (module (func (result {retty})
+                                (f32.{op} (f32.const {left}) (f32.const {right}))))
+                        ", retty = RETTY, op = OP, left = a, right = b)).execute_func::<(), $retty>(0, ()) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn lit_reg(a: f32, b: f32) -> bool {
+                        use std::sync::Once;
+
+                        let translated = translate_wat(&format!("
+                            (module (func (param f32) (result {retty})
+                                (f32.{op} (f32.const {left}) (get_local 0))))
+                        ", retty = RETTY, op = OP, left = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(f32,), $retty>(0, (b,)) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn reg_lit(a: f32, b: f32) -> bool {
+                        use std::sync::Once;
+
+                        let translated = translate_wat(&format!("
+                            (module (func (param f32) (result {retty})
+                                (f32.{op} (get_local 0) (f32.const {right}))))
+                        ", retty = RETTY, op = OP, right = b));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(f32,), $retty>(0, (a,)) == Ok($func(a, b) as $retty)
+                    }
+                }
+            }
+        };
+    }
+
+    macro_rules! unop_test {
+        ($name:ident, $func:expr) => {
+            unop_test!($name, $func, f32);
+        };
+        ($name:ident, $func:expr, $out_ty:ty) => {
+            mod $name {
+                use super::{translate_wat, ExecutableModule};
+                use std::sync::Once;
+
+                lazy_static! {
+                    static ref AS_PARAM: ExecutableModule = translate_wat(concat!(
+                        "(module (func (param f32) (result ",
+                        stringify!($out_ty),
+                        ")
+                            (f32.",
+                        stringify!($name),
+                        " (get_local 0))))"
+                    ),);
+                }
+
+                quickcheck! {
+                    fn as_param(a: f32) -> bool {
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| AS_PARAM.disassemble());
+                        AS_PARAM.execute_func::<(f32,), $out_ty>(0, (a,)) == Ok($func(a))
+                    }
+
+                    fn lit(a: f32) -> bool {
+                                                let translated = translate_wat(&format!(concat!("
+                            (module (func (result ",stringify!($out_ty),")
+                                (f32.",stringify!($name)," (f32.const {val}))))
+                        "), val = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(), $out_ty>(0, ()) == Ok($func(a))
+                    }
+                }
+            }
+        };
+    }
+
+    binop_test!(add, |a, b| a + b);
+    binop_test!(mul, |a, b| a * b);
+    binop_test!(sub, |a, b| a - b);
+    binop_test!(gt, |a, b| a > b, i32);
+    binop_test!(lt, |a, b| a < b, i32);
+    binop_test!(ge, |a, b| a >= b, i32);
+    binop_test!(le, |a, b| a <= b, i32);
+
+    unop_test!(neg, |a: f32| -a);
+}
+
+mod opf64 {
+    use super::{translate_wat, ExecutableModule};
+
+    macro_rules! binop_test {
+        ($op:ident, $func:expr) => {
+            binop_test!($op, $func, f64);
+        };
+        ($op:ident, $func:expr, $retty:ident) => {
+            mod $op {
+                use super::{translate_wat, ExecutableModule};
+
+                const RETTY: &str = stringify!($retty);
+                const OP: &str = stringify!($op);
+
+                lazy_static! {
+                    static ref AS_PARAMS: ExecutableModule = translate_wat(&format!("
+                        (module (func (param f64) (param f64) (result {retty})
+                            (f64.{op} (get_local 0) (get_local 1))))
+                    ", retty = RETTY, op = OP));
+                }
+
+                quickcheck! {
+                    fn as_params(a: f64, b: f64) -> bool {
+                        AS_PARAMS.execute_func::<(f64, f64), $retty>(0, (a, b)) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn lit_lit(a: f64, b: f64) -> bool {
+                        translate_wat(&format!("
+                            (module (func (result {retty})
+                                (f64.{op} (f64.const {left}) (f64.const {right}))))
+                        ", retty = RETTY, op = OP, left = a, right = b)).execute_func::<(), $retty>(0, ()) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn lit_reg(a: f64, b: f64) -> bool {
+                        use std::sync::Once;
+
+                        let translated = translate_wat(&format!("
+                            (module (func (param f64) (result {retty})
+                                (f64.{op} (f64.const {left}) (get_local 0))))
+                        ", retty = RETTY, op = OP, left = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(f64,), $retty>(0, (b,)) == Ok($func(a, b) as $retty)
+                    }
+
+                    fn reg_lit(a: f64, b: f64) -> bool {
+                        use std::sync::Once;
+
+                        let translated = translate_wat(&format!("
+                            (module (func (param f64) (result {retty})
+                                (f64.{op} (get_local 0) (f64.const {right}))))
+                        ", retty = RETTY, op = OP, right = b));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(f64,), $retty>(0, (a,)) == Ok($func(a, b) as $retty)
+                    }
+                }
+            }
+        };
+    }
+
+    macro_rules! unop_test {
+        ($name:ident, $func:expr) => {
+            unop_test!($name, $func, f64);
+        };
+        ($name:ident, $func:expr, $out_ty:ty) => {
+            mod $name {
+                use super::{translate_wat, ExecutableModule};
+                use std::sync::Once;
+
+                lazy_static! {
+                    static ref AS_PARAM: ExecutableModule = translate_wat(concat!(
+                        "(module (func (param f64) (result ",
+                        stringify!($out_ty),
+                        ")
+                            (f64.",
+                        stringify!($name),
+                        " (get_local 0))))"
+                    ),);
+                }
+
+                quickcheck! {
+                    fn as_param(a: f64) -> bool {
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| AS_PARAM.disassemble());
+                        AS_PARAM.execute_func::<(f64,), $out_ty>(0, (a,)) == Ok($func(a))
+                    }
+
+                    fn lit(a: f64) -> bool {
+                                                let translated = translate_wat(&format!(concat!("
+                            (module (func (result ",stringify!($out_ty),")
+                                (f64.",stringify!($name)," (f64.const {val}))))
+                        "), val = a));
+                        static ONCE: Once = Once::new();
+                        ONCE.call_once(|| translated.disassemble());
+
+                        translated.execute_func::<(), $out_ty>(0, ()) == Ok($func(a))
+                    }
+                }
+            }
+        };
+    }
+
+    binop_test!(add, |a, b| a + b);
+    binop_test!(mul, |a, b| a * b);
+    binop_test!(sub, |a, b| a - b);
+    binop_test!(gt, |a, b| a > b, i32);
+    binop_test!(lt, |a, b| a < b, i32);
+    binop_test!(ge, |a, b| a >= b, i32);
+    binop_test!(le, |a, b| a <= b, i32);
+
+    unop_test!(neg, |a: f64| -a);
+}
+
+quickcheck! {
+    fn if_then_else(a: u32, b: u32) -> bool {
+        const CODE: &str = r#"
 (module
   (func (param i32) (param i32) (result i32)
     (if (result i32)
@@ -78,13 +537,17 @@ fn if_then_else() {
     )
   )
 )
-    "#;
+        "#;
 
-    for (a, b, expected) in CASES {
-        assert_eq!(execute_wat(code, *a, *b), *expected, "{}, {}", a, b);
+        lazy_static! {
+            static ref TRANSLATED: ExecutableModule = {let out = translate_wat(CODE); out.disassemble(); out};
+        }
+
+        let out = TRANSLATED.execute_func::<(u32, u32), u32>(0, (a, b));
+
+        out == Ok(if a == b { a } else { b })
     }
 }
-
 #[test]
 fn if_without_result() {
     let code = r#"
@@ -130,7 +593,7 @@ fn function_call() {
 }
 
 #[test]
-fn large_function_call() {
+fn large_function() {
     let code = r#"
 (module
   (func (param i32) (param i32) (param i32) (param i32)
@@ -155,31 +618,466 @@ fn large_function_call() {
     assert_eq!(
         {
             let translated = translate_wat(code);
-            let out: u32 = unsafe { translated.execute_func(0, (5, 4, 3, 2, 1, 0)) };
+            translated.disassemble();
+            let out: Result<u32, _> = translated.execute_func(0, (5, 4, 3, 2, 1, 0));
             out
         },
-        5
+        Ok(5)
     );
 }
 
 #[test]
-fn literals() {
+fn function_read_args_spill_to_stack() {
+    let code = r#"
+(module
+  (func (param i32) (param i32) (param i32) (param i32)
+        (param i32) (param i32) (param i32) (param i32)
+        (param i32) (param i32) (param i32) (param i32)
+        (result i32)
+
+    (call $assert_zero
+      (get_local 7)
+    )
+    (get_local 0)
+  )
+
+  (func $assert_zero (param $v i32)
+    (local i32)
+    (if (get_local $v)
+      (unreachable)
+    )
+  )
+)
+    "#;
+
+    assert_eq!(
+        {
+            let translated = translate_wat(code);
+            translated.disassemble();
+            translated.execute_func(
+                0,
+                (
+                    7u32, 6u32, 5u32, 4u32, 3u32, 2u32, 1u32, 0u32, 1u32, 2u32, 3u32, 4u32,
+                ),
+            )
+        },
+        Ok(7u32)
+    );
+}
+
+macro_rules! mk_function_write_args_spill_to_stack {
+    ($name:ident, $typ:ty) => {
+        #[test]
+        fn $name() {
+            let code = format!(
+                "
+(module
+  (func (param {typ}) (param {typ}) (param {typ}) (param {typ})
+        (param {typ}) (param {typ}) (param {typ}) (param {typ})
+        (param {typ}) (param {typ}) (param {typ}) (param {typ})
+        (result {typ})
+
+    (call $called
+      (get_local 0)
+      (get_local 1)
+      (get_local 2)
+      (get_local 3)
+      (get_local 4)
+      (get_local 5)
+      (get_local 6)
+      (get_local 7)
+      (get_local 8)
+      (get_local 9)
+      (get_local 10)
+      (get_local 11)
+    )
+  )
+
+  (func $called
+        (param {typ}) (param {typ}) (param {typ}) (param {typ})
+        (param {typ}) (param {typ}) (param {typ}) (param {typ})
+        (param {typ}) (param {typ}) (param {typ}) (param {typ})
+        (result {typ})
+
+    (call $assert_zero
+      (get_local 11)
+    )
+    (get_local 0)
+  )
+
+  (func $assert_zero (param $v {typ})
+    (local {typ})
+    (if ({typ}.ne (get_local $v) ({typ}.const 0))
+      (unreachable)
+    )
+  )
+)
+    ",
+                typ = stringify!($typ)
+            );
+
+            assert_eq!(
+                {
+                    let translated = translate_wat(&code);
+                    translated.disassemble();
+                    let out: Result<$typ, _> = translated.execute_func(
+                        0,
+                        (
+                            11 as $typ, 10 as $typ, 9 as $typ, 8 as $typ, 7 as $typ, 6 as $typ,
+                            5 as $typ, 4 as $typ, 3 as $typ, 2 as $typ, 1 as $typ, 0 as $typ,
+                        ),
+                    );
+                    out
+                },
+                Ok(11)
+            );
+        }
+    };
+}
+
+mk_function_write_args_spill_to_stack!(function_write_args_spill_to_stack_i32, i32);
+mk_function_write_args_spill_to_stack!(function_write_args_spill_to_stack_i64, i64);
+
+#[test]
+fn block() {
     let code = r#"
 (module
   (func (param i32) (param i32) (result i32)
+    (block (result i32)
+        get_local 0
+    )
+  )
+)
+    "#;
+    assert_eq!(execute_wat(code, 10, 20), 10);
+}
+
+#[test]
+fn br_block() {
+    let code = r#"
+(module
+  (func (param i32) (param i32) (result i32)
+    get_local 1
+    (block (result i32)
+        get_local 0
+        get_local 0
+        br 0
+        unreachable
+    )
+    i32.add
+  )
+)
+    "#;
+
+    let translated = translate_wat(code);
+    translated.disassemble();
+
+    assert_eq!(
+        translated.execute_func::<(i32, i32), i32>(0, (5, 7)),
+        Ok(12)
+    );
+}
+
+// Tests discarding values on the value stack, while
+// carrying over the result using a conditional branch.
+#[test]
+fn brif_block() {
+    let code = r#"
+(module
+  (func (param i32) (param i32) (result i32)
+    get_local 1
+    (block (result i32)
+        get_local 0
+        get_local 0
+        br_if 0
+        unreachable
+    )
+    i32.add
+  )
+)
+    "#;
+    assert_eq!(execute_wat(code, 5, 7), 12);
+}
+
+#[test]
+fn spec_loop() {
+    let code = r#"
+(module
+  (func
+    (call $assert-eq (call $as-binary-operand) (i32.const 12))
+    (call $assert-eq (call $break-bare) (i32.const 19))
+    (call $assert-eq (call $break-value) (i32.const 18))
+    (call $assert-eq (call $break-repeated) (i32.const 18))
+    (call $assert-eq (call $break-inner) (i32.const 0x7))
+  )
+  (func $dummy)
+  (func $as-binary-operand (result i32)
+    (i32.mul
+      (loop (result i32) (call $dummy) (i32.const 3))
+      (loop (result i32) (call $dummy) (i32.const 4))
+    )
+  )
+  (func $break-bare (result i32)
+    (block (loop (br 1) (br 0) (unreachable)))
+    (block (loop (br_if 1 (i32.const 1)) (unreachable)))
+    (i32.const 19)
+  )
+  (func $break-value (result i32)
+    (block (result i32)
+      (loop (result i32) (br 1 (i32.const 18)) (br 0) (i32.const 19))
+    )
+  )
+  (func $break-repeated (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (br 1 (i32.const 18))
+        (br 1 (i32.const 19))
+        (drop (br_if 1 (i32.const 20) (i32.const 0)))
+        (drop (br_if 1 (i32.const 20) (i32.const 1)))
+        (br 1 (i32.const 21))
+        (i32.const 21)
+      )
+    )
+  )
+  (func $break-inner (result i32)
+    (local i32)
+    (set_local 0 (i32.const 0))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (get_local 0)
+  )
+  (func $assert-eq (param i32) (param i32)
+     (if (i32.ne (get_local 0) (get_local 1))
+        (unreachable)
+     )
+  )
+)
+"#;
+
+    let translated = translate_wat(code);
+    translated.disassemble();
+    translated.execute_func::<(), ()>(0, ()).unwrap();
+}
+
+quickcheck! {
+    fn spec_fac(n: i8) -> bool {
+        const CODE: &str = r#"
+            (module
+              (func (param i32) (result i32)
+                (local i32)
+                (set_local 1 (call $fac-iter (get_local 0)))
+                (call $assert-eq (get_local 1) (call $fac-opt (get_local 0)))
+                (get_local 1)
+              )
+
+              (func $assert-eq (param i32) (param i32)
+                 (if (i32.ne (get_local 0) (get_local 1))
+                    (unreachable)
+                 )
+              )
+
+              ;; Iterative factorial
+              (func $fac-iter (param i32) (result i32)
+                (local i32 i32)
+                (set_local 1 (get_local 0))
+                (set_local 2 (i32.const 1))
+                (block
+                  (loop
+                    (if
+                      (i32.lt_s (get_local 1) (i32.const 2))
+                      (then (br 2))
+                      (else
+                        (set_local 2 (i32.mul (get_local 1) (get_local 2)))
+                        (set_local 1 (i32.sub (get_local 1) (i32.const 1)))
+                      )
+                    )
+                    (br 0)
+                  )
+                )
+                (get_local 2)
+              )
+            
+              ;; Optimized factorial.
+              (func $fac-opt (param i32) (result i32)
+                (local i32)
+                (set_local 1 (i32.const 1))
+                (block
+                  (br_if 0 (i32.lt_s (get_local 0) (i32.const 2)))
+                  (loop
+                    (set_local 1 (i32.mul (get_local 1) (get_local 0)))
+                    (set_local 0 (i32.add (get_local 0) (i32.const -1)))
+                    (br_if 0 (i32.gt_s (get_local 0) (i32.const 1)))
+                  )
+                )
+                (get_local 1)
+              )
+            )"#;
+
+        fn fac(mut n: i32) -> i32 {
+            let mut a = 1i32;
+
+            while n > 1 {
+                a = a.wrapping_mul(n);
+                n -= 1;
+            }
+
+            a
+        }
+
+        lazy_static! {
+            static ref TRANSLATED: ExecutableModule = {
+                let out = translate_wat(CODE);
+                out.disassemble();
+                out
+            };
+        }
+
+        let n = n as i32;
+
+        assert_eq!(TRANSLATED.execute_func::<(i32,), i32>(2, (n,)), Ok(fac(n)));
+        assert_eq!(TRANSLATED.execute_func::<(i32,), i32>(3, (n,)), Ok(fac(n)));
+        true
+    }
+}
+
+// Tests that br_if keeps values in the case if the branch
+// hasn't been taken.
+#[test]
+fn brif_block_passthru() {
+    let code = r#"
+(module
+  (func (param i32) (param i32) (result i32)
+    (block (result i32)
+        get_local 1
+        get_local 0
+        br_if 0
+        get_local 1
+        i32.add
+    )
+  )
+)
+    "#;
+    assert_eq!(execute_wat(code, 0, 3), 6);
+}
+
+quickcheck! {
+    #[test]
+    fn literals(a: i32, b: i64, c: i32, d: i64) -> bool {
+        let code = format!(r#"
+            (module
+              (func (result i32)
+                (i32.const {})
+              )
+              (func (result i64)
+                (i64.const {})
+              )
+              (func (result f32)
+                (f32.const {})
+              )
+              (func (result f64)
+                (f64.const {})
+              )
+            )
+        "#, a, b, c, d);
+
+        let translated = translate_wat(&code);
+
+        assert_eq!(translated.execute_func::<(), i32>(0, ()), Ok(a));
+        assert_eq!(translated.execute_func::<(), i64>(1, ()), Ok(b));
+        assert_eq!(translated.execute_func::<(), f32>(2, ()), Ok(c as _));
+        assert_eq!(translated.execute_func::<(), f64>(3, ()), Ok(d as _));
+
+        true
+    }
+}
+
+quickcheck! {
+    #[test]
+    fn params(a: i32, b: i64, c: i32, d: i64) -> bool {
+        let code = r#"
+            (module
+              (func (param i32) (param i64) (param f32) (param f64) (result i32)
+                (get_local 0)
+              )
+              (func (param i32) (param i64) (param f32) (param f64) (result i64)
+                (get_local 1)
+              )
+              (func (param i32) (param i64) (param f32) (param f64) (result f32)
+                (get_local 2)
+              )
+              (func (param i32) (param i64) (param f32) (param f64) (result f64)
+                (get_local 3)
+              )
+            )
+        "#;
+
+        let c = c as f32;
+        let d = d as f64;
+
+        let translated = translate_wat(&code);
+
+        assert_eq!(translated.execute_func::<(i32, i64, f32, f64), i32>(0, (a, b, c, d)), Ok(a));
+        assert_eq!(translated.execute_func::<(i32, i64, f32, f64), i64>(1, (a, b, c, d)), Ok(b));
+        assert_eq!(translated.execute_func::<(i32, i64, f32, f64), f32>(2, (a, b, c, d)), Ok(c));
+        assert_eq!(translated.execute_func::<(i32, i64, f32, f64), f64>(3, (a, b, c, d)), Ok(d));
+
+        true
+    }
+}
+#[test]
+fn wrong_type() {
+    let code = r#"
+(module
+  (func (param i32) (param i64) (result i32)
     (i32.const 228)
   )
 )
     "#;
 
-    assert_eq!(execute_wat(code, 0, 0), 228);
+    let translated = translate_wat(code);
+    assert_eq!(
+        translated
+            .execute_func::<_, ()>(0, (0u32, 0u32))
+            .unwrap_err(),
+        ExecutionError::TypeMismatch
+    );
 }
 
 #[test]
-fn fib() {
+fn wrong_index() {
     let code = r#"
 (module
-  (func $fib (param $n i32) (param $_unused i32) (result i32)
+  (func (param i32) (param i64) (result i32)
+    (i32.const 228)
+  )
+)
+    "#;
+
+    let translated = translate_wat(code);
+    assert_eq!(
+        translated
+            .execute_func::<_, ()>(10, (0u32, 0u32))
+            .unwrap_err(),
+        ExecutionError::FuncIndexOutOfBounds
+    );
+}
+
+fn iterative_fib_baseline(n: u32) -> u32 {
+    let (mut a, mut b) = (1, 1);
+
+    for _ in 0..n {
+        let old_a = a;
+        a = b;
+        b += old_a;
+    }
+
+    a
+}
+
+const FIBONACCI: &str = r#"
+(module
+  (func $fib (param $n i32) (result i32)
     (if (result i32)
       (i32.eq
         (i32.const 0)
@@ -205,7 +1103,6 @@ fn fib() {
                   (get_local $n)
                   (i32.const -1)
                 )
-                (i32.const 0)
               )
               ;; fib(n - 2)
               (call $fib
@@ -213,7 +1110,6 @@ fn fib() {
                   (get_local $n)
                   (i32.const -2)
                 )
-                (i32.const 0)
               )
             )
           )
@@ -224,12 +1120,699 @@ fn fib() {
 )
     "#;
 
-    // fac(x) = y <=> (x, y)
-    const FIB_SEQ: &[u32] = &[1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+#[test]
+fn fib_unopt() {
+    let translated = translate_wat(FIBONACCI);
+    translated.disassemble();
 
-    for x in 0..10 {
-        assert_eq!(execute_wat(code, x, 0), FIB_SEQ[x as usize]);
+    for x in 0..30 {
+        assert_eq!(
+            translated.execute_func::<_, u32>(0, (x,)),
+            Ok(iterative_fib_baseline(x)),
+            "Failed for x={}",
+            x
+        );
     }
 }
 
-// TODO: Add a test that checks argument passing via the stack.
+// Generated by Rust for the `fib` function in `bench_fibonacci_baseline`
+const FIBONACCI_OPT: &str = r"
+(module
+  (func $fib (param $p0 i32) (result i32)
+    (local $l1 i32)
+    (set_local $l1
+      (i32.const 1))
+    (block $B0
+      (br_if $B0
+        (i32.lt_u
+          (get_local $p0)
+          (i32.const 2)))
+      (set_local $l1
+        (i32.const 1))
+      (loop $L1
+        (set_local $l1
+          (i32.add
+            (call $fib
+              (i32.add
+                (get_local $p0)
+                (i32.const -1)))
+            (get_local $l1)))
+        (br_if $L1
+          (i32.gt_u
+            (tee_local $p0
+              (i32.add
+                (get_local $p0)
+                (i32.const -2)))
+            (i32.const 1)))))
+    (get_local $l1)))";
+
+#[test]
+fn fib_opt() {
+    let translated = translate_wat(FIBONACCI_OPT);
+    translated.disassemble();
+
+    for x in 0..30 {
+        assert_eq!(
+            translated.execute_func::<_, u32>(0, (x,)),
+            Ok(iterative_fib_baseline(x)),
+            "Failed for x={}",
+            x
+        );
+    }
+}
+
+#[test]
+fn br_table() {
+    const CODE: &str = r"
+(module
+  (func
+    (block (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func
+    (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func
+    (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0)))
+  )
+  (func $dummy)
+)
+";
+
+    let translated = translate_wat(CODE);
+    translated.disassemble();
+
+    println!("as-block-first");
+    assert_eq!(
+        translated.execute_func::<_, ()>(0, ()),
+        Ok(()),
+    );
+    println!("as-block-mid");
+    assert_eq!(
+        translated.execute_func::<_, ()>(1, ()),
+        Ok(()),
+    );
+    println!("as-block-last");
+    assert_eq!(
+        translated.execute_func::<_, ()>(2, ()),
+        Ok(()),
+    );
+}
+
+#[test]
+fn storage() {
+    const CODE: &str = r#"
+(module
+  (memory 1 1)
+
+  (func (result i32)
+    (local i32 i32 i32)
+    (set_local 0 (i32.const 10))
+    (block
+      (loop
+        (if
+          (i32.eq (get_local 0) (i32.const 0))
+          (then (br 2))
+        )
+        (set_local 2 (i32.mul (get_local 0) (i32.const 4)))
+        (i32.store (get_local 2) (get_local 0))
+        (set_local 1 (i32.load (get_local 2)))
+        (if
+          (i32.ne (get_local 0) (get_local 1))
+          (then (return (i32.const 0)))
+        )
+        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
+        (br 0)
+      )
+    )
+    (i32.const 1)
+  )
+)"#;
+
+    let translated = translate_wat(CODE);
+    translated.disassemble();
+
+    assert_eq!(translated.execute_func::<(), i32>(0, ()), Ok(1));
+}
+
+#[test]
+fn nested_storage_calls() {
+    const CODE: &str = r#"
+(module
+  (memory 1 1)
+
+  (func (result i32)
+    (local i32 i32 i32)
+    (set_local 0 (i32.const 10))
+    (block
+      (loop
+        (if
+          (i32.eq (get_local 0) (i32.const 0))
+          (then (br 2))
+        )
+        (set_local 2 (i32.mul (get_local 0) (i32.const 4)))
+        (call $assert_eq (call $inner) (i32.const 1))
+        (i32.store (get_local 2) (get_local 0))
+        (set_local 1 (i32.load (get_local 2)))
+        (if
+          (i32.ne (get_local 0) (get_local 1))
+          (then (return (i32.const 0)))
+        )
+        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
+        (br 0)
+      )
+    )
+    (i32.const 1)
+  )
+
+  (func $assert_eq (param $a i32) (param $b i32)
+    (if (i32.ne (get_local $a) (get_local $b))
+      (unreachable)
+    )
+  )
+
+  (func $inner (result i32)
+    (local i32 i32 i32)
+    (set_local 0 (i32.const 10))
+    (block
+      (loop
+        (if
+          (i32.eq (get_local 0) (i32.const 0))
+          (then (br 2))
+        )
+        (set_local 2 (i32.mul (get_local 0) (i32.const 4)))
+        (i32.store (get_local 2) (get_local 0))
+        (set_local 1 (i32.load (get_local 2)))
+        (if
+          (i32.ne (get_local 0) (get_local 1))
+          (then (return (i32.const 0)))
+        )
+        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
+        (br 0)
+      )
+    )
+    (i32.const 1)
+  )
+)"#;
+
+    let translated = translate_wat(CODE);
+    translated.disassemble();
+
+    assert_eq!(translated.execute_func::<(), i32>(0, ()), Ok(1));
+}
+
+// TODO: Signature mismatches correctly fail at time of writing this comment,
+//       but we can't add a test for that until we implement traps properly.
+#[test]
+fn call_indirect() {
+    const CODE: &str = r#"
+(module
+  (type $over-i64 (func (param i64) (result i64)))
+
+  (table anyfunc
+    (elem
+      $fac $fib
+    )
+  )
+
+  (func $dispatch (param i32 i64) (result i64)
+    (call_indirect (type $over-i64) (get_local 1) (get_local 0))
+  )
+
+  (func $fac (type $over-i64)
+    (if (result i64) (i64.eqz (get_local 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (get_local 0)
+          (call_indirect (type $over-i64)
+            (i64.sub (get_local 0) (i64.const 1))
+            (i32.const 0)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib (type $over-i64)
+    (if (result i64) (i64.le_u (get_local 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect (type $over-i64)
+            (i64.sub (get_local 0) (i64.const 2))
+            (i32.const 1)
+          )
+          (call_indirect (type $over-i64)
+            (i64.sub (get_local 0) (i64.const 1))
+            (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+)"#;
+
+    let wasm = wabt::wat2wasm(CODE).unwrap();
+    let module = translate(&wasm).unwrap();
+
+    module.disassemble();
+
+    assert_eq!(
+        module.execute_func::<(i32, i64), i64>(0, (0, 10)).unwrap(),
+        3628800
+    );
+    assert_eq!(
+        module.execute_func::<(i32, i64), i64>(0, (1, 10)).unwrap(),
+        89
+    );
+}
+
+macro_rules! test_select {
+    ($name:ident, $ty:ident) => {
+        mod $name {
+            use super::{translate_wat, ExecutableModule};
+            use std::sync::Once;
+
+            lazy_static! {
+                static ref AS_PARAMS: ExecutableModule = translate_wat(&format!(
+                    "
+                    (module
+                        (func (param {ty}) (param {ty}) (param i32) (result {ty})
+                            (select (get_local 0) (get_local 1) (get_local 2))
+                        )
+                    )",
+                    ty = stringify!($ty)
+                ));
+            }
+
+            quickcheck! {
+                fn as_param(cond: bool, then: $ty, else_: $ty) -> bool {
+                     let icond: i32 = if cond { 1 } else { 0 };
+                     AS_PARAMS.execute_func::<($ty, $ty, i32), $ty>(0, (then, else_, icond)) ==
+                        Ok(if cond { then } else { else_ })
+                }
+
+                fn lit(cond: bool, then: $ty, else_: $ty) -> bool {
+                    let icond: i32 = if cond { 1 } else { 0 };
+                                                    let translated = translate_wat(&format!("
+                            (module (func (param {ty}) (param {ty}) (result {ty})
+                                (select (get_local 0) (get_local 1) (i32.const {val}))))
+                        ",
+                        val = icond,
+                        ty = stringify!($ty)
+                    ));
+                    static ONCE: Once = Once::new();
+                    ONCE.call_once(|| translated.disassemble());
+
+                    translated.execute_func::<($ty, $ty), $ty>(0, (then, else_)) ==
+                        Ok(if cond { then } else { else_ })
+                }
+            }
+        }
+    };
+}
+
+test_select!(select32, i32);
+test_select!(select64, i64);
+
+#[bench]
+fn bench_fibonacci_compile(b: &mut test::Bencher) {
+    let wasm = wabt::wat2wasm(FIBONACCI).unwrap();
+
+    b.iter(|| test::black_box(translate(&wasm).unwrap()));
+}
+
+#[bench]
+fn bench_fibonacci_run(b: &mut test::Bencher) {
+    let wasm = wabt::wat2wasm(FIBONACCI_OPT).unwrap();
+    let module = translate(&wasm).unwrap();
+
+    b.iter(|| module.execute_func::<_, u32>(0, (20,)));
+}
+
+#[bench]
+fn bench_fibonacci_compile_run(b: &mut test::Bencher) {
+    let wasm = wabt::wat2wasm(FIBONACCI).unwrap();
+
+    b.iter(|| translate(&wasm).unwrap().execute_func::<_, u32>(0, (20,)));
+}
+
+#[bench]
+fn bench_fibonacci_baseline(b: &mut test::Bencher) {
+    fn fib(n: i32) -> i32 {
+        if n == 0 || n == 1 {
+            1
+        } else {
+            fib(n - 1) + fib(n - 2)
+        }
+    }
+
+    b.iter(|| test::black_box(fib(test::black_box(20))));
+}
+
+// #[test]
+#[allow(dead_code)]
+fn sieve() {
+    const CODE: &str = r#"
+(module
+  (type $t0 (func (param i32 i32)))
+  (type $t1 (func (param i32 i32 i32) (result i32)))
+  (type $t2 (func (param i32 i32 i32)))
+  (type $t3 (func (param i32)))
+  (type $t4 (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)))
+  (type $t5 (func (param i32 i32) (result i32)))
+  (func $optimized_sieve (export "optimized_sieve") (type $t0) (param $p0 i32) (param $p1 i32)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32) (local $l13 i32) (local $l14 i32) (local $l15 i32) (local $l16 i32) (local $l17 i32) (local $l18 f64)
+    get_global $g0
+    i32.const 64
+    i32.sub
+    tee_local $l0
+    set_global $g0
+    i32.const 0
+    set_local $l1
+    get_local $l0
+    i32.const 0
+    i32.const 64
+    call $memset
+    set_local $l0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            get_local $p1
+            i32.const 2
+            i32.gt_u
+            br_if $B3
+            i32.const -1
+            i32.const 0
+            get_local $p1
+            i32.const 2
+            i32.eq
+            select
+            set_local $p1
+            i32.const 0
+            set_local $l2
+            i32.const 0
+            set_local $l3
+            i32.const 0
+            set_local $l4
+            i32.const 0
+            set_local $l5
+            i32.const 0
+            set_local $l6
+            i32.const 0
+            set_local $l7
+            i32.const 0
+            set_local $l8
+            i32.const 0
+            set_local $l9
+            i32.const 0
+            set_local $l10
+            i32.const 0
+            set_local $l11
+            i32.const 0
+            set_local $l12
+            i32.const 0
+            set_local $l13
+            i32.const 0
+            set_local $l14
+            i32.const 0
+            set_local $l15
+            i32.const 0
+            set_local $l16
+            i32.const 0
+            set_local $l17
+            br $B2
+          end
+          get_local $p1
+          i32.const -3
+          i32.add
+          i32.const 1
+          i32.shr_u
+          set_local $l3
+          block $B4
+            block $B5
+              get_local $p1
+              f64.convert_u/i32
+              f64.sqrt
+              tee_local $l18
+              f64.const 0x1p+32 (;=4.29497e+09;)
+              f64.lt
+              get_local $l18
+              f64.const 0x0p+0 (;=0;)
+              f64.ge
+              i32.and
+              br_if $B5
+              i32.const 0
+              set_local $p1
+              br $B4
+            end
+            get_local $l18
+            i32.trunc_u/f64
+            set_local $p1
+          end
+          get_local $l3
+          i32.const 1
+          i32.add
+          set_local $l17
+          get_local $p1
+          i32.const -3
+          i32.add
+          i32.const 1
+          i32.shr_u
+          set_local $l5
+          i32.const 0
+          set_local $p1
+          loop $L6
+            get_local $p1
+            tee_local $l4
+            i32.const 5
+            i32.shr_u
+            set_local $p1
+            get_local $l4
+            i32.const 511
+            i32.gt_u
+            br_if $B0
+            block $B7
+              get_local $l0
+              get_local $p1
+              i32.const 2
+              i32.shl
+              i32.add
+              i32.load
+              i32.const 1
+              get_local $l4
+              i32.const 31
+              i32.and
+              i32.shl
+              i32.and
+              br_if $B7
+              get_local $l4
+              i32.const 1
+              i32.shl
+              i32.const 3
+              i32.add
+              tee_local $l2
+              get_local $l2
+              i32.mul
+              i32.const -3
+              i32.add
+              i32.const 1
+              i32.shr_u
+              tee_local $p1
+              get_local $l3
+              i32.gt_u
+              br_if $B7
+              loop $L8
+                get_local $p1
+                i32.const 5
+                i32.shr_u
+                set_local $l1
+                get_local $p1
+                i32.const 511
+                i32.gt_u
+                br_if $B1
+                get_local $l0
+                get_local $l1
+                i32.const 2
+                i32.shl
+                i32.add
+                tee_local $l1
+                get_local $l1
+                i32.load
+                i32.const 1
+                get_local $p1
+                i32.const 31
+                i32.and
+                i32.shl
+                i32.or
+                i32.store
+                get_local $p1
+                get_local $l2
+                i32.add
+                tee_local $p1
+                get_local $l3
+                i32.le_u
+                br_if $L8
+              end
+            end
+            get_local $l4
+            i32.const 1
+            i32.add
+            set_local $p1
+            get_local $l4
+            get_local $l5
+            i32.lt_u
+            br_if $L6
+          end
+          i32.const -1
+          set_local $p1
+          get_local $l0
+          i32.load offset=60
+          set_local $l1
+          get_local $l0
+          i32.load offset=56
+          set_local $l2
+          get_local $l0
+          i32.load offset=52
+          set_local $l3
+          get_local $l0
+          i32.load offset=48
+          set_local $l4
+          get_local $l0
+          i32.load offset=44
+          set_local $l5
+          get_local $l0
+          i32.load offset=40
+          set_local $l6
+          get_local $l0
+          i32.load offset=36
+          set_local $l7
+          get_local $l0
+          i32.load offset=32
+          set_local $l8
+          get_local $l0
+          i32.load offset=28
+          set_local $l9
+          get_local $l0
+          i32.load offset=24
+          set_local $l10
+          get_local $l0
+          i32.load offset=20
+          set_local $l11
+          get_local $l0
+          i32.load offset=16
+          set_local $l12
+          get_local $l0
+          i32.load offset=12
+          set_local $l13
+          get_local $l0
+          i32.load offset=8
+          set_local $l14
+          get_local $l0
+          i32.load offset=4
+          set_local $l15
+          get_local $l0
+          i32.load
+          set_local $l16
+        end
+        get_local $p0
+        get_local $l1
+        i32.store offset=68
+        get_local $p0
+        get_local $l2
+        i32.store offset=64
+        get_local $p0
+        get_local $l3
+        i32.store offset=60
+        get_local $p0
+        get_local $l4
+        i32.store offset=56
+        get_local $p0
+        get_local $l5
+        i32.store offset=52
+        get_local $p0
+        get_local $l6
+        i32.store offset=48
+        get_local $p0
+        get_local $l7
+        i32.store offset=44
+        get_local $p0
+        get_local $l8
+        i32.store offset=40
+        get_local $p0
+        get_local $l9
+        i32.store offset=36
+        get_local $p0
+        get_local $l10
+        i32.store offset=32
+        get_local $p0
+        get_local $l11
+        i32.store offset=28
+        get_local $p0
+        get_local $l12
+        i32.store offset=24
+        get_local $p0
+        get_local $l13
+        i32.store offset=20
+        get_local $p0
+        get_local $l14
+        i32.store offset=16
+        get_local $p0
+        get_local $l15
+        i32.store offset=12
+        get_local $p0
+        get_local $l16
+        i32.store offset=8
+        get_local $p0
+        get_local $l17
+        i32.store offset=4
+        get_local $p0
+        get_local $p1
+        i32.store
+        get_local $l0
+        i32.const 64
+        i32.add
+        set_global $g0
+        return
+      end
+      i32.const 1396
+      get_local $l1
+      i32.const 16
+      unreachable
+    end
+    i32.const 1380
+    get_local $p1
+    i32.const 16
+    unreachable)
+  (func $memset (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l0 i32)
+    block $B0
+      get_local $p2
+      i32.eqz
+      br_if $B0
+      get_local $p0
+      set_local $l0
+      loop $L1
+        get_local $l0
+        get_local $p1
+        i32.store8
+        get_local $l0
+        i32.const 1
+        i32.add
+        set_local $l0
+        get_local $p2
+        i32.const -1
+        i32.add
+        tee_local $p2
+        br_if $L1
+      end
+    end
+    get_local $p0)
+  (memory $memory (export "memory") 17 17)
+  (global $g0 (mut i32) (i32.const 1050032)))
+"#;
+
+    translate(&wabt::wat2wasm(CODE).unwrap()).unwrap();
+}
+
diff --git a/src/translate_sections.rs b/src/translate_sections.rs
index 94d248d517..a163e1980f 100644
--- a/src/translate_sections.rs
+++ b/src/translate_sections.rs
@@ -1,22 +1,23 @@
 use backend::{CodeGenSession, TranslatedCodeSection};
 use error::Error;
 use function_body;
-use module::TranslationContext;
+use microwasm::{MicrowasmConv, Type as MWType};
+use module::{ModuleContext, SimpleContext};
 #[allow(unused_imports)] // for now
 use wasmparser::{
     CodeSectionReader, Data, DataSectionReader, Element, ElementSectionReader, Export,
     ExportSectionReader, ExternalKind, FuncType, FunctionSectionReader, Global,
     GlobalSectionReader, GlobalType, Import, ImportSectionEntryType, ImportSectionReader,
-    MemorySectionReader, MemoryType, Operator, TableSectionReader, Type, TypeSectionReader,
+    MemorySectionReader, MemoryType, Operator, TableSectionReader, TableType, Type,
+    TypeSectionReader,
 };
 
 /// Parses the Type section of the wasm module.
 pub fn type_(types_reader: TypeSectionReader) -> Result<Vec<FuncType>, Error> {
-    let mut types = vec![];
-    for entry in types_reader {
-        types.push(entry?);
-    }
-    Ok(types)
+    types_reader
+        .into_iter()
+        .map(|r| r.map_err(Into::into))
+        .collect()
 }
 
 /// Parses the Import section of the wasm module.
@@ -29,27 +30,23 @@ pub fn import(imports: ImportSectionReader) -> Result<(), Error> {
 
 /// Parses the Function section of the wasm module.
 pub fn function(functions: FunctionSectionReader) -> Result<Vec<u32>, Error> {
-    let mut func_ty_indicies = vec![];
-    for entry in functions {
-        func_ty_indicies.push(entry?);
-    }
-    Ok(func_ty_indicies)
+    functions
+        .into_iter()
+        .map(|r| r.map_err(Into::into))
+        .collect()
 }
 
 /// Parses the Table section of the wasm module.
-pub fn table(tables: TableSectionReader) -> Result<(), Error> {
-    for entry in tables {
-        entry?; // TODO
-    }
-    Ok(())
+pub fn table(tables: TableSectionReader) -> Result<Vec<TableType>, Error> {
+    tables.into_iter().map(|r| r.map_err(Into::into)).collect()
 }
 
 /// Parses the Memory section of the wasm module.
-pub fn memory(memories: MemorySectionReader) -> Result<(), Error> {
-    for entry in memories {
-        entry?; // TODO
-    }
-    Ok(())
+pub fn memory(memories: MemorySectionReader) -> Result<Vec<MemoryType>, Error> {
+    memories
+        .into_iter()
+        .map(|r| r.map_err(Into::into))
+        .collect()
 }
 
 /// Parses the Global section of the wasm module.
@@ -75,23 +72,57 @@ pub fn start(_index: u32) -> Result<(), Error> {
 }
 
 /// Parses the Element section of the wasm module.
-pub fn element(elements: ElementSectionReader) -> Result<(), Error> {
+pub fn element(elements: ElementSectionReader) -> Result<Vec<u32>, Error> {
+    let mut out = Vec::new();
+
     for entry in elements {
-        entry?; // TODO
+        let entry = entry?;
+
+        assert_eq!(entry.table_index, 0);
+        let offset = {
+            let mut reader = entry.init_expr.get_operators_reader();
+            let out = match reader.read() {
+                Ok(Operator::I32Const { value }) => value,
+                _ => panic!("We only support i32.const table init expressions right now"),
+            };
+
+            //reader.ensure_end()?;
+
+            out
+        };
+
+        assert_eq!(offset, out.len() as i32);
+
+        let elements = entry
+            .items
+            .get_items_reader()?
+            .into_iter()
+            .collect::<Result<Vec<_>, _>>()?;
+
+        out.extend(elements);
     }
-    Ok(())
+
+    Ok(out)
 }
 
 /// Parses the Code section of the wasm module.
 pub fn code(
     code: CodeSectionReader,
-    translation_ctx: &TranslationContext,
+    translation_ctx: &SimpleContext,
 ) -> Result<TranslatedCodeSection, Error> {
     let func_count = code.get_count();
-    let mut session = CodeGenSession::new(func_count);
+    let mut session = CodeGenSession::new(func_count, translation_ctx);
+
     for (idx, body) in code.into_iter().enumerate() {
-        function_body::translate(&mut session, translation_ctx, idx as u32, &body?)?;
+        let body = body?;
+
+        function_body::translate_wasm(
+            &mut session,
+            idx as u32,
+            &body,
+        )?;
     }
+
     Ok(session.into_translated_code_section()?)
 }
 
diff --git a/wasmparser.rs b/wasmparser.rs
new file mode 160000
index 0000000000..e8bc42b377
--- /dev/null
+++ b/wasmparser.rs
@@ -0,0 +1 @@
+Subproject commit e8bc42b377559fb8be6bc333cceb36857d3f0d9c