Re-structure and decouple AST from generator

codegen-luajit/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "codegen-luajit"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies.wasm-ast]
+path = "../wasm-ast"
+
+[dependencies.parity-wasm]
+git = "https://github.com/paritytech/parity-wasm.git"
+features = ["multi_value", "sign_ext"]

codegen-luajit/runtime/runtime.lua

@@ -0,0 +1,501 @@
+local module = {}
+
+local bit = require("bit")
+local ffi = require("ffi")
+
+local u32 = ffi.typeof("uint32_t")
+local u64 = ffi.typeof("uint64_t")
+local i64 = ffi.typeof("int64_t")
+
+local math_ceil = math.ceil
+local math_floor = math.floor
+local to_number = tonumber
+
+local function truncate(num)
+	if num >= 0 then
+		return (math_floor(num))
+	else
+		return (math_ceil(num))
+	end
+end
+
+do
+	local add = {}
+	local sub = {}
+	local mul = {}
+	local div = {}
+
+	local num_meta = debug.getmetatable(i64)
+	local to_signed = bit.tobit
+
+	function add.i32(a, b)
+		return (to_signed(a + b))
+	end
+	add.i64 = num_meta.__add
+
+	function sub.i32(a, b)
+		return (to_signed(a - b))
+	end
+	sub.i64 = num_meta.__sub
+
+	function mul.i32(a, b)
+		return (to_signed(a * b))
+	end
+	mul.i64 = num_meta.__mul
+
+	function div.i32(lhs, rhs)
+		assert(rhs ~= 0, "division by zero")
+
+		return (truncate(lhs / rhs))
+	end
+
+	function div.u32(lhs, rhs)
+		assert(rhs ~= 0, "division by zero")
+
+		lhs = to_number(u32(lhs))
+		rhs = to_number(u32(rhs))
+
+		return (to_signed(math_floor(lhs / rhs)))
+	end
+
+	function div.u64(lhs, rhs)
+		assert(rhs ~= 0, "division by zero")
+
+		return (i64(u64(lhs) / u64(rhs)))
+	end
+
+	module.add = add
+	module.sub = sub
+	module.mul = mul
+	module.div = div
+end
+
+do
+	local clz = {}
+	local ctz = {}
+	local popcnt = {}
+
+	local lj_band = bit.band
+	local lj_lshift = bit.lshift
+
+	function clz.i32(num)
+		for i = 0, 31 do
+			local mask = lj_lshift(1, 31 - i)
+
+			if lj_band(num, mask) ~= 0 then
+				return i
+			end
+		end
+
+		return 32
+	end
+
+	function ctz.i32(num)
+		for i = 0, 31 do
+			local mask = lj_lshift(1, i)
+
+			if lj_band(num, mask) ~= 0 then
+				return i
+			end
+		end
+
+		return 32
+	end
+
+	function popcnt.i32(num)
+		local count = 0
+
+		while num ~= 0 do
+			num = lj_band(num, num - 1)
+			count = count + 1
+		end
+
+		return count
+	end
+
+	module.clz = clz
+	module.ctz = ctz
+	module.popcnt = popcnt
+end
+
+do
+	local le = {}
+	local lt = {}
+	local ge = {}
+	local gt = {}
+
+	function ge.u32(lhs, rhs)
+		return u32(lhs) >= u32(rhs)
+	end
+
+	function ge.u64(lhs, rhs)
+		return u64(lhs) >= u64(rhs)
+	end
+
+	function gt.u32(lhs, rhs)
+		return u32(lhs) > u32(rhs)
+	end
+
+	function gt.u64(lhs, rhs)
+		return u64(lhs) > u64(rhs)
+	end
+
+	function le.u32(lhs, rhs)
+		return u32(lhs) <= u32(rhs)
+	end
+
+	function le.u64(lhs, rhs)
+		return u64(lhs) <= u64(rhs)
+	end
+
+	function lt.u32(lhs, rhs)
+		return u32(lhs) < u32(rhs)
+	end
+
+	function lt.u64(lhs, rhs)
+		return u64(lhs) < u64(rhs)
+	end
+
+	module.le = le
+	module.lt = lt
+	module.ge = ge
+	module.gt = gt
+end
+
+do
+	local band = {}
+	local bor = {}
+	local bxor = {}
+	local bnot = {}
+
+	band.i32 = bit.band
+	band.i64 = bit.band
+
+	bnot.i32 = bit.bnot
+	bnot.i64 = bit.bnot
+
+	bor.i32 = bit.bor
+	bor.i64 = bit.bor
+
+	bxor.i32 = bit.bxor
+	bxor.i64 = bit.bxor
+
+	module.band = band
+	module.bor = bor
+	module.bxor = bxor
+	module.bnot = bnot
+end
+
+do
+	local shl = {}
+	local shr = {}
+	local rotl = {}
+	local rotr = {}
+
+	rotl.i32 = bit.rol
+	rotl.i64 = bit.rol
+
+	rotr.i32 = bit.ror
+	rotr.i64 = bit.ror
+
+	shl.i32 = bit.lshift
+	shl.i64 = bit.lshift
+	shl.u32 = bit.lshift
+	shl.u64 = bit.lshift
+
+	shr.i32 = bit.arshift
+	shr.i64 = bit.arshift
+	shr.u32 = bit.rshift
+	shr.u64 = bit.rshift
+
+	module.shl = shl
+	module.shr = shr
+	module.rotl = rotl
+	module.rotr = rotr
+end
+
+do
+	local wrap = {}
+	local trunc = {}
+	local extend = {}
+	local convert = {}
+	local reinterpret = {}
+
+	-- This would surely be an issue in a multi-thread environment...
+	-- ... thankfully this isn't one.
+	local RE_INSTANCE = ffi.new([[union {
+		int32_t i32;
+		int64_t i64;
+		float f32;
+		double f64;
+	}]])
+
+	function wrap.i32_i64(num)
+		RE_INSTANCE.i64 = num
+
+		return RE_INSTANCE.i32
+	end
+
+	trunc.i32_f32 = truncate
+	trunc.i32_f64 = truncate
+	trunc.u32_f32 = truncate
+	trunc.u32_f64 = truncate
+	trunc.i64_f32 = i64
+	trunc.i64_f64 = i64
+	trunc.u64_f32 = i64
+	trunc.u64_f64 = i64
+
+	extend.i64_i32 = i64
+
+	function extend.u64_i32(num)
+		RE_INSTANCE.i64 = 0
+		RE_INSTANCE.i32 = num
+
+		return RE_INSTANCE.i64
+	end
+
+	function convert.f32_i32(num)
+		return num
+	end
+
+	function convert.f32_u32(num)
+		return (to_number(u32(num)))
+	end
+
+	function convert.f32_i64(num)
+		return (to_number(num))
+	end
+
+	function convert.f32_u64(num)
+		return (to_number(u64(num)))
+	end
+
+	function convert.f64_i32(num)
+		return num
+	end
+
+	function convert.f64_u32(num)
+		return (to_number(u32(num)))
+	end
+
+	function convert.f64_i64(num)
+		return (to_number(num))
+	end
+
+	function convert.f64_u64(num)
+		return (to_number(u64(num)))
+	end
+
+	function reinterpret.i32_f32(num)
+		RE_INSTANCE.f32 = num
+
+		return RE_INSTANCE.i32
+	end
+
+	function reinterpret.i64_f64(num)
+		RE_INSTANCE.f64 = num
+
+		return RE_INSTANCE.i64
+	end
+
+	function reinterpret.f32_i32(num)
+		RE_INSTANCE.i32 = num
+
+		return RE_INSTANCE.f32
+	end
+
+	function reinterpret.f64_i64(num)
+		RE_INSTANCE.i64 = num
+
+		return RE_INSTANCE.f64
+	end
+
+	module.wrap = wrap
+	module.trunc = trunc
+	module.extend = extend
+	module.convert = convert
+	module.reinterpret = reinterpret
+end
+
+do
+	local load = {}
+	local store = {}
+	local allocator = {}
+
+	ffi.cdef([[
+	union Any {
+		int8_t i8;
+		int16_t i16;
+		int32_t i32;
+		int64_t i64;
+
+		uint8_t u8;
+		uint16_t u16;
+		uint32_t u32;
+		uint64_t u64;
+
+		float f32;
+		double f64;
+	};
+
+	struct Memory {
+		uint32_t min;
+		uint32_t max;
+		union Any *data;
+	};
+
+	void *calloc(size_t num, size_t size);
+	void *realloc(void *ptr, size_t size);
+	void free(void *ptr);
+	]])
+
+	local alias_t = ffi.typeof("uint8_t *")
+	local any_t = ffi.typeof("union Any *")
+	local cast = ffi.cast
+
+	local function by_offset(pointer, offset)
+		local aliased = cast(alias_t, pointer)
+
+		return cast(any_t, aliased + offset)
+	end
+
+	function load.i32_i8(memory, addr)
+		return by_offset(memory.data, addr).i8
+	end
+
+	function load.i32_u8(memory, addr)
+		return by_offset(memory.data, addr).u8
+	end
+
+	function load.i32_i16(memory, addr)
+		return by_offset(memory.data, addr).i16
+	end
+
+	function load.i32_u16(memory, addr)
+		return by_offset(memory.data, addr).u16
+	end
+
+	function load.i32(memory, addr)
+		return by_offset(memory.data, addr).i32
+	end
+
+	function load.i64_i8(memory, addr)
+		return (i64(by_offset(memory.data, addr).i8))
+	end
+
+	function load.i64_u8(memory, addr)
+		return (i64(by_offset(memory.data, addr).u8))
+	end
+
+	function load.i64_i16(memory, addr)
+		return (i64(by_offset(memory.data, addr).i16))
+	end
+
+	function load.i64_u16(memory, addr)
+		return (i64(by_offset(memory.data, addr).u16))
+	end
+
+	function load.i64_i32(memory, addr)
+		return (i64(by_offset(memory.data, addr).i32))
+	end
+
+	function load.i64_u32(memory, addr)
+		return (i64(by_offset(memory.data, addr).u32))
+	end
+
+	function load.i64(memory, addr)
+		return by_offset(memory.data, addr).i64
+	end
+
+	function load.f32(memory, addr)
+		return by_offset(memory.data, addr).f32
+	end
+
+	function load.f64(memory, addr)
+		return by_offset(memory.data, addr).f64
+	end
+
+	function store.i32_n8(memory, addr, value)
+		by_offset(memory.data, addr).i8 = value
+	end
+
+	function store.i32_n16(memory, addr, value)
+		by_offset(memory.data, addr).i16 = value
+	end
+
+	function store.i32(memory, addr, value)
+		by_offset(memory.data, addr).i32 = value
+	end
+
+	function store.i64_n8(memory, addr, value)
+		by_offset(memory.data, addr).i8 = value
+	end
+
+	function store.i64_n16(memory, addr, value)
+		by_offset(memory.data, addr).i16 = value
+	end
+
+	function store.i64_n32(memory, addr, value)
+		by_offset(memory.data, addr).i32 = value
+	end
+
+	function store.i64(memory, addr, value)
+		by_offset(memory.data, addr).i64 = value
+	end
+
+	function store.f32(memory, addr, value)
+		by_offset(memory.data, addr).f32 = value
+	end
+
+	function store.f64(memory, addr, value)
+		by_offset(memory.data, addr).f64 = value
+	end
+
+	local WASM_PAGE_SIZE = 65536
+
+	local function finalizer(memory)
+		ffi.C.free(memory.data)
+	end
+
+	local function grow_unchecked(memory, old, new)
+		memory.data = ffi.C.realloc(memory.data, new)
+
+		assert(memory.data ~= nil, "failed to reallocate")
+
+		ffi.fill(by_offset(memory.data, old), new - old, 0)
+	end
+
+	function allocator.new(min, max)
+		local data = ffi.C.calloc(max, WASM_PAGE_SIZE)
+
+		assert(data ~= nil, "failed to allocate")
+
+		local memory = ffi.new("struct Memory", min, max, data)
+
+		return ffi.gc(memory, finalizer)
+	end
+
+	function allocator.init(memory, addr, data)
+		ffi.copy(by_offset(memory.data, addr), data, #data - 1)
+	end
+
+	function allocator.grow(memory, num)
+		local old = memory.min
+		local new = old + num
+
+		if new > memory.max then
+			return -1
+		else
+			grow_unchecked(memory, old * WASM_PAGE_SIZE, new * WASM_PAGE_SIZE)
+			memory.min = new
+
+			return old
+		end
+	end
+
+	module.load = load
+	module.store = store
+	module.allocator = allocator
+end
+
+return module

codegen-luajit/src/analyzer/localize.rs

@@ -0,0 +1,60 @@
+use std::collections::BTreeSet;
+
+use wasm_ast::{
+	node::{AnyBinOp, AnyCmpOp, AnyLoad, AnyStore, AnyUnOp, Function},
+	visit::{Driver, Visitor},
+};
+
+struct Visit {
+	result: BTreeSet<(&'static str, &'static str)>,
+}
+
+impl Visitor for Visit {
+	fn visit_any_load(&mut self, v: &AnyLoad) {
+		let name = v.op.as_name();
+
+		self.result.insert(("load", name));
+	}
+
+	fn visit_any_store(&mut self, v: &AnyStore) {
+		let name = v.op.as_name();
+
+		self.result.insert(("store", name));
+	}
+
+	fn visit_any_unop(&mut self, v: &AnyUnOp) {
+		let name = v.op.as_name();
+
+		self.result.insert(name);
+	}
+
+	fn visit_any_binop(&mut self, v: &AnyBinOp) {
+		if v.op.as_operator().is_some() {
+			return;
+		}
+
+		let name = v.op.as_name();
+
+		self.result.insert(name);
+	}
+
+	fn visit_any_cmpop(&mut self, v: &AnyCmpOp) {
+		if v.op.as_operator().is_some() {
+			return;
+		}
+
+		let name = v.op.as_name();
+
+		self.result.insert(name);
+	}
+}
+
+pub fn visit(func: &Function) -> BTreeSet<(&'static str, &'static str)> {
+	let mut visit = Visit {
+		result: BTreeSet::new(),
+	};
+
+	func.accept(&mut visit);
+
+	visit.result
+}

codegen-luajit/src/analyzer/memory.rs

@@ -0,0 +1,38 @@
+use std::collections::BTreeSet;
+
+use wasm_ast::{
+	node::{AnyLoad, AnyStore, Function, MemoryGrow, MemorySize},
+	visit::{Driver, Visitor},
+};
+
+struct Visit {
+	result: BTreeSet<u8>,
+}
+
+impl Visitor for Visit {
+	fn visit_any_store(&mut self, _: &AnyStore) {
+		self.result.insert(0);
+	}
+
+	fn visit_any_load(&mut self, _: &AnyLoad) {
+		self.result.insert(0);
+	}
+
+	fn visit_memory_size(&mut self, m: &MemorySize) {
+		self.result.insert(m.memory);
+	}
+
+	fn visit_memory_grow(&mut self, m: &MemoryGrow) {
+		self.result.insert(m.memory);
+	}
+}
+
+pub fn visit(func: &Function) -> BTreeSet<u8> {
+	let mut visit = Visit {
+		result: BTreeSet::new(),
+	};
+
+	func.accept(&mut visit);
+
+	visit.result
+}

codegen-luajit/src/analyzer/mod.rs

@@ -0,0 +1,2 @@
+pub mod localize;
+pub mod memory;

codegen-luajit/src/gen.rs

@@ -0,0 +1,874 @@
+use std::{collections::BTreeSet, io::Result, ops::Range};
+
+use parity_wasm::elements::{
+	External, ImportCountType, Instruction, Internal, Module, NameSection, ResizableLimits,
+};
+
+use wasm_ast::{
+	builder::{Arities, Builder},
+	node::{
+		AnyBinOp, AnyCmpOp, AnyLoad, AnyStore, AnyUnOp, Backward, Br, BrIf, BrTable, Call,
+		CallIndirect, Else, Expression, Forward, Function, GetGlobal, GetLocal, If, Memorize,
+		MemoryGrow, MemorySize, Recall, Return, Select, SetGlobal, SetLocal, Statement, Value,
+	},
+	writer::{Transpiler, Writer},
+};
+
+use crate::analyzer::{localize, memory};
+
+fn aux_internal_index(internal: Internal) -> u32 {
+	match internal {
+		Internal::Function(v) | Internal::Table(v) | Internal::Memory(v) | Internal::Global(v) => v,
+	}
+}
+
+fn new_limit_max(limits: &ResizableLimits) -> String {
+	match limits.maximum() {
+		Some(v) => v.to_string(),
+		None => "0xFFFF".to_string(),
+	}
+}
+
+fn write_table_init(limit: &ResizableLimits, w: Writer) -> Result<()> {
+	let a = limit.initial();
+	let b = new_limit_max(limit);
+
+	write!(w, "{{ min = {}, max = {}, data = {{}} }}", a, b)
+}
+
+fn write_memory_init(limit: &ResizableLimits, w: Writer) -> Result<()> {
+	let a = limit.initial();
+	let b = new_limit_max(limit);
+
+	write!(w, "rt.allocator.new({}, {})", a, b)
+}
+
+fn write_func_name(wasm: &Module, index: u32, offset: u32, w: Writer) -> Result<()> {
+	let opt = wasm
+		.names_section()
+		.and_then(NameSection::functions)
+		.and_then(|v| v.names().get(index));
+
+	write!(w, "FUNC_LIST")?;
+
+	if let Some(name) = opt {
+		write!(w, "--[[{}]]", name)?;
+	}
+
+	write!(w, "[{}] =", index + offset)
+}
+
+fn write_in_order(prefix: &str, len: u32, w: Writer) -> Result<()> {
+	if len == 0 {
+		return Ok(());
+	}
+
+	write!(w, "{}_{}", prefix, 0)?;
+	(1..len).try_for_each(|i| write!(w, ", {}_{}", prefix, i))
+}
+
+fn write_f32(f: f32, w: Writer) -> Result<()> {
+	let sign = if f.is_sign_negative() { "-" } else { "" };
+
+	if f.is_infinite() {
+		write!(w, "{}math.huge ", sign)
+	} else if f.is_nan() {
+		write!(w, "{}0/0 ", sign)
+	} else {
+		write!(w, "{:e} ", f)
+	}
+}
+
+fn write_f64(f: f64, w: Writer) -> Result<()> {
+	let sign = if f.is_sign_negative() { "-" } else { "" };
+
+	if f.is_infinite() {
+		write!(w, "{}math.huge ", sign)
+	} else if f.is_nan() {
+		write!(w, "{}0/0 ", sign)
+	} else {
+		write!(w, "{:e} ", f)
+	}
+}
+
+fn write_list(name: &str, len: usize, w: Writer) -> Result<()> {
+	let hash = len.min(1);
+	let len = len.saturating_sub(1);
+
+	write!(w, "local {} = table_new({}, {})", name, len, hash)
+}
+
+fn write_parameter_list(func: &Function, w: Writer) -> Result<()> {
+	write!(w, "function(")?;
+	write_in_order("param", func.num_param, w)?;
+	write!(w, ")")
+}
+
+fn write_result_list(range: Range<u32>, w: Writer) -> Result<()> {
+	if range.is_empty() {
+		return Ok(());
+	}
+
+	range.clone().try_for_each(|i| {
+		if i != range.start {
+			write!(w, ", ")?;
+		}
+
+		write!(w, "reg_{}", i)
+	})?;
+
+	write!(w, " = ")
+}
+
+fn write_variable_list(func: &Function, w: Writer) -> Result<()> {
+	if !func.local_list.is_empty() {
+		let num_local = func.local_list.len().try_into().unwrap();
+
+		write!(w, "local ")?;
+		write_in_order("loc", num_local, w)?;
+		write!(w, " = ")?;
+
+		for (i, t) in func.local_list.iter().enumerate() {
+			if i != 0 {
+				write!(w, ", ")?;
+			}
+
+			write!(w, "ZERO_{} ", t)?;
+		}
+	}
+
+	if func.num_stack != 0 {
+		write!(w, "local ")?;
+		write_in_order("reg", func.num_stack, w)?;
+		write!(w, " ")?;
+	}
+
+	Ok(())
+}
+
+fn write_expression(code: &[Instruction], w: Writer) -> Result<()> {
+	// FIXME: Badly generated WASM will produce the wrong constant.
+	for inst in code {
+		let result = match *inst {
+			Instruction::I32Const(v) => write!(w, "{} ", v),
+			Instruction::I64Const(v) => write!(w, "{}LL ", v),
+			Instruction::F32Const(v) => write_f32(f32::from_bits(v), w),
+			Instruction::F64Const(v) => write_f64(f64::from_bits(v), w),
+			Instruction::GetGlobal(i) => write!(w, "GLOBAL_LIST[{}].value ", i),
+			_ => {
+				continue;
+			}
+		};
+
+		return result;
+	}
+
+	write!(w, "error(\"mundane expression\")")
+}
+
+fn condense_jump_table(list: &[u32]) -> Vec<(usize, usize, u32)> {
+	let mut result = Vec::new();
+	let mut index = 0;
+
+	while index < list.len() {
+		let start = index;
+
+		loop {
+			index += 1;
+
+			// if end of list or next value is not equal, break
+			if index == list.len() || list[index - 1] != list[index] {
+				break;
+			}
+		}
+
+		result.push((start, index - 1, list[start]));
+	}
+
+	result
+}
+
+#[derive(Default)]
+struct Visitor {
+	label_list: Vec<usize>,
+	num_label: usize,
+	num_param: u32,
+}
+
+impl Visitor {
+	fn push_label(&mut self) -> usize {
+		self.label_list.push(self.num_label);
+		self.num_label += 1;
+
+		self.num_label - 1
+	}
+
+	fn pop_label(&mut self) {
+		self.label_list.pop().unwrap();
+	}
+
+	fn get_label(&self, up: u32) -> usize {
+		let last = self.label_list.len() - 1;
+
+		self.label_list[last - up as usize]
+	}
+}
+
+trait Driver {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()>;
+}
+
+impl Driver for Recall {
+	fn visit(&self, _: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "reg_{} ", self.var)
+	}
+}
+
+impl Driver for Select {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "(")?;
+		write_as_condition(&self.cond, v, w)?;
+		write!(w, "and ")?;
+		self.a.visit(v, w)?;
+		write!(w, "or ")?;
+		self.b.visit(v, w)?;
+		write!(w, ")")
+	}
+}
+
+fn write_variable(var: u32, v: &Visitor, w: Writer) -> Result<()> {
+	if let Some(rem) = var.checked_sub(v.num_param) {
+		write!(w, "loc_{} ", rem)
+	} else {
+		write!(w, "param_{} ", var)
+	}
+}
+
+impl Driver for GetLocal {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write_variable(self.var, v, w)
+	}
+}
+
+impl Driver for GetGlobal {
+	fn visit(&self, _: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "GLOBAL_LIST[{}].value ", self.var)
+	}
+}
+
+impl Driver for AnyLoad {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "load_{}(memory_at_0, ", self.op.as_name())?;
+		self.pointer.visit(v, w)?;
+		write!(w, "+ {})", self.offset)
+	}
+}
+
+impl Driver for MemorySize {
+	fn visit(&self, _: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "memory_at_{}.min ", self.memory)
+	}
+}
+
+impl Driver for MemoryGrow {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "rt.allocator.grow(memory_at_{}, ", self.memory)?;
+		self.value.visit(v, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for Value {
+	fn visit(&self, _: &mut Visitor, w: Writer) -> Result<()> {
+		match self {
+			Self::I32(i) => write!(w, "{} ", i),
+			Self::I64(i) => write!(w, "{}LL ", i),
+			Self::F32(f) => write_f32(*f, w),
+			Self::F64(f) => write_f64(*f, w),
+		}
+	}
+}
+
+impl Driver for AnyUnOp {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		let (a, b) = self.op.as_name();
+
+		write!(w, "{}_{}(", a, b)?;
+		self.rhs.visit(v, w)?;
+		write!(w, ")")
+	}
+}
+
+fn write_bin_call(
+	op: (&str, &str),
+	lhs: &Expression,
+	rhs: &Expression,
+	v: &mut Visitor,
+	w: Writer,
+) -> Result<()> {
+	write!(w, "{}_{}(", op.0, op.1)?;
+	lhs.visit(v, w)?;
+	write!(w, ", ")?;
+	rhs.visit(v, w)?;
+	write!(w, ")")
+}
+
+impl Driver for AnyBinOp {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		if let Some(op) = self.op.as_operator() {
+			write!(w, "(")?;
+			self.lhs.visit(v, w)?;
+			write!(w, "{} ", op)?;
+			self.rhs.visit(v, w)?;
+			write!(w, ")")
+		} else {
+			write_bin_call(self.op.as_name(), &self.lhs, &self.rhs, v, w)
+		}
+	}
+}
+
+fn write_any_cmp(cmp: &AnyCmpOp, v: &mut Visitor, w: Writer) -> Result<()> {
+	if let Some(op) = cmp.op.as_operator() {
+		cmp.lhs.visit(v, w)?;
+		write!(w, "{} ", op)?;
+		cmp.rhs.visit(v, w)
+	} else {
+		write_bin_call(cmp.op.as_name(), &cmp.lhs, &cmp.rhs, v, w)
+	}
+}
+
+impl Driver for AnyCmpOp {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "(")?;
+		write_any_cmp(self, v, w)?;
+		write!(w, "and 1 or 0)")
+	}
+}
+
+// Removes the boolean to integer conversion
+fn write_as_condition(data: &Expression, v: &mut Visitor, w: Writer) -> Result<()> {
+	if let Expression::AnyCmpOp(o) = data {
+		write_any_cmp(o, v, w)
+	} else {
+		data.visit(v, w)?;
+		write!(w, "~= 0 ")
+	}
+}
+
+fn write_expr_list(list: &[Expression], v: &mut Visitor, w: Writer) -> Result<()> {
+	list.iter().enumerate().try_for_each(|(i, e)| {
+		if i != 0 {
+			write!(w, ", ")?;
+		}
+
+		e.visit(v, w)
+	})
+}
+
+impl Driver for Expression {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		match self {
+			Self::Recall(e) => e.visit(v, w),
+			Self::Select(e) => e.visit(v, w),
+			Self::GetLocal(e) => e.visit(v, w),
+			Self::GetGlobal(e) => e.visit(v, w),
+			Self::AnyLoad(e) => e.visit(v, w),
+			Self::MemorySize(e) => e.visit(v, w),
+			Self::MemoryGrow(e) => e.visit(v, w),
+			Self::Value(e) => e.visit(v, w),
+			Self::AnyUnOp(e) => e.visit(v, w),
+			Self::AnyBinOp(e) => e.visit(v, w),
+			Self::AnyCmpOp(e) => e.visit(v, w),
+		}
+	}
+}
+
+impl Driver for Memorize {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "reg_{} = ", self.var)?;
+		self.value.visit(v, w)
+	}
+}
+
+impl Driver for Forward {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		let label = v.push_label();
+
+		self.body.iter().try_for_each(|s| s.visit(v, w))?;
+
+		write!(w, "::continue_at_{}::", label)?;
+
+		v.pop_label();
+
+		Ok(())
+	}
+}
+
+impl Driver for Backward {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		let label = v.push_label();
+
+		write!(w, "::continue_at_{}::", label)?;
+		write!(w, "while true do ")?;
+
+		self.body.iter().try_for_each(|s| s.visit(v, w))?;
+
+		write!(w, "break ")?;
+		write!(w, "end ")?;
+
+		v.pop_label();
+
+		Ok(())
+	}
+}
+
+impl Driver for Else {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "else ")?;
+
+		self.body.iter().try_for_each(|s| s.visit(v, w))
+	}
+}
+
+impl Driver for If {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		let label = v.push_label();
+
+		write!(w, "if ")?;
+		write_as_condition(&self.cond, v, w)?;
+		write!(w, "then ")?;
+
+		self.truthy.iter().try_for_each(|s| s.visit(v, w))?;
+
+		if let Some(s) = &self.falsey {
+			s.visit(v, w)?;
+		}
+
+		write!(w, "::continue_at_{}::", label)?;
+		write!(w, "end ")?;
+
+		v.pop_label();
+
+		Ok(())
+	}
+}
+
+fn write_br_at(up: u32, v: &Visitor, w: Writer) -> Result<()> {
+	let level = v.get_label(up);
+
+	write!(w, "goto continue_at_{} ", level)
+}
+
+impl Driver for Br {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write_br_at(self.target, v, w)
+	}
+}
+
+impl Driver for BrIf {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "if ")?;
+		write_as_condition(&self.cond, v, w)?;
+		write!(w, "then ")?;
+
+		write_br_at(self.target, v, w)?;
+
+		write!(w, "end ")
+	}
+}
+
+impl Driver for BrTable {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "temp = ")?;
+		self.cond.visit(v, w)?;
+		write!(w, " ")?;
+
+		for (start, end, dest) in condense_jump_table(&self.data.table) {
+			if start == end {
+				write!(w, "if temp == {} then ", start)?;
+			} else {
+				write!(w, "if temp >= {} and temp <= {} then ", start, end)?;
+			}
+
+			write_br_at(dest, v, w)?;
+			write!(w, "else")?;
+		}
+
+		write!(w, " ")?;
+		write_br_at(self.data.default, v, w)?;
+		write!(w, "end ")
+	}
+}
+
+impl Driver for Return {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "do return ")?;
+
+		write_expr_list(&self.list, v, w)?;
+
+		write!(w, "end ")
+	}
+}
+
+impl Driver for Call {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write_result_list(self.result.clone(), w)?;
+
+		write!(w, "FUNC_LIST[{}](", self.func)?;
+
+		write_expr_list(&self.param_list, v, w)?;
+
+		write!(w, ")")
+	}
+}
+
+impl Driver for CallIndirect {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write_result_list(self.result.clone(), w)?;
+
+		write!(w, "TABLE_LIST[{}].data[", self.table)?;
+
+		self.index.visit(v, w)?;
+
+		write!(w, "](")?;
+
+		write_expr_list(&self.param_list, v, w)?;
+
+		write!(w, ")")
+	}
+}
+
+impl Driver for SetLocal {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write_variable(self.var, v, w)?;
+
+		write!(w, "= ")?;
+		self.value.visit(v, w)
+	}
+}
+
+impl Driver for SetGlobal {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "GLOBAL_LIST[{}].value = ", self.var)?;
+		self.value.visit(v, w)
+	}
+}
+
+impl Driver for AnyStore {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write!(w, "store_{}(memory_at_0, ", self.op.as_name())?;
+		self.pointer.visit(v, w)?;
+		write!(w, "+ {}, ", self.offset)?;
+		self.value.visit(v, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for Statement {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		match self {
+			Self::Unreachable => write!(w, "error(\"out of code bounds\")"),
+			Self::Memorize(s) => s.visit(v, w),
+			Self::Forward(s) => s.visit(v, w),
+			Self::Backward(s) => s.visit(v, w),
+			Self::If(s) => s.visit(v, w),
+			Self::Br(s) => s.visit(v, w),
+			Self::BrIf(s) => s.visit(v, w),
+			Self::BrTable(s) => s.visit(v, w),
+			Self::Return(s) => s.visit(v, w),
+			Self::Call(s) => s.visit(v, w),
+			Self::CallIndirect(s) => s.visit(v, w),
+			Self::SetLocal(s) => s.visit(v, w),
+			Self::SetGlobal(s) => s.visit(v, w),
+			Self::AnyStore(s) => s.visit(v, w),
+		}
+	}
+}
+
+impl Driver for Function {
+	fn visit(&self, v: &mut Visitor, w: Writer) -> Result<()> {
+		write_parameter_list(self, w)?;
+
+		for v in memory::visit(self) {
+			write!(w, "local memory_at_{0} = MEMORY_LIST[{0}]", v)?;
+		}
+
+		write_variable_list(self, w)?;
+		write!(w, "local temp ")?;
+
+		v.num_param = self.num_param;
+		self.body.visit(v, w)?;
+
+		write!(w, "end ")
+	}
+}
+
+pub struct Generator<'a> {
+	wasm: &'a Module,
+	arity: Arities,
+}
+
+static RUNTIME: &str = include_str!("../runtime/runtime.lua");
+
+impl<'a> Transpiler<'a> for Generator<'a> {
+	fn new(wasm: &'a Module) -> Self {
+		let arity = Arities::new(wasm);
+
+		Self { wasm, arity }
+	}
+
+	fn runtime(w: Writer) -> Result<()> {
+		write!(w, "{}", RUNTIME)
+	}
+
+	fn transpile(&self, w: Writer) -> Result<()> {
+		write!(w, "local rt = require(\"luajit\")")?;
+
+		let func_list = self.build_func_list();
+
+		Self::gen_localize(&func_list, w)?;
+
+		write!(w, "local ZERO_i32 = 0 ")?;
+		write!(w, "local ZERO_i64 = 0LL ")?;
+		write!(w, "local ZERO_f32 = 0.0 ")?;
+		write!(w, "local ZERO_f64 = 0.0 ")?;
+
+		write!(w, "local table_new = require(\"table.new\")")?;
+		write_list("FUNC_LIST", self.wasm.functions_space(), w)?;
+		write_list("TABLE_LIST", self.wasm.table_space(), w)?;
+		write_list("MEMORY_LIST", self.wasm.memory_space(), w)?;
+		write_list("GLOBAL_LIST", self.wasm.globals_space(), w)?;
+
+		self.gen_func_list(&func_list, w)?;
+		self.gen_start_point(w)
+	}
+}
+
+impl<'a> Generator<'a> {
+	fn gen_import_of<T>(&self, w: Writer, lower: &str, cond: T) -> Result<()>
+	where
+		T: Fn(&External) -> bool,
+	{
+		let import = match self.wasm.import_section() {
+			Some(v) => v.entries(),
+			None => return Ok(()),
+		};
+		let upper = lower.to_uppercase();
+
+		for (i, v) in import.iter().filter(|v| cond(v.external())).enumerate() {
+			let field = v.field();
+			let module = v.module();
+
+			write!(w, "{}[{}] = wasm.{}.{}.{} ", upper, i, module, lower, field)?;
+		}
+
+		Ok(())
+	}
+
+	fn gen_export_of<T>(&self, w: Writer, lower: &str, cond: T) -> Result<()>
+	where
+		T: Fn(&Internal) -> bool,
+	{
+		let export = match self.wasm.export_section() {
+			Some(v) => v.entries(),
+			None => return Ok(()),
+		};
+		let upper = lower.to_uppercase();
+
+		write!(w, "{} = {{", lower)?;
+
+		for v in export.iter().filter(|v| cond(v.internal())) {
+			let field = v.field();
+			let index = aux_internal_index(*v.internal());
+
+			write!(w, "{} = {}[{}],", field, upper, index)?;
+		}
+
+		write!(w, "}},")
+	}
+
+	fn gen_import_list(&self, w: Writer) -> Result<()> {
+		self.gen_import_of(w, "func_list", |v| matches!(v, External::Function(_)))?;
+		self.gen_import_of(w, "table_list", |v| matches!(v, External::Table(_)))?;
+		self.gen_import_of(w, "memory_list", |v| matches!(v, External::Memory(_)))?;
+		self.gen_import_of(w, "global_list", |v| matches!(v, External::Global(_)))
+	}
+
+	fn gen_export_list(&self, w: Writer) -> Result<()> {
+		self.gen_export_of(w, "func_list", |v| matches!(v, Internal::Function(_)))?;
+		self.gen_export_of(w, "table_list", |v| matches!(v, Internal::Table(_)))?;
+		self.gen_export_of(w, "memory_list", |v| matches!(v, Internal::Memory(_)))?;
+		self.gen_export_of(w, "global_list", |v| matches!(v, Internal::Global(_)))
+	}
+
+	fn gen_table_list(&self, w: Writer) -> Result<()> {
+		let table = match self.wasm.table_section() {
+			Some(v) => v.entries(),
+			None => return Ok(()),
+		};
+		let offset = self.wasm.import_count(ImportCountType::Table);
+
+		for (i, v) in table.iter().enumerate() {
+			let index = i + offset;
+
+			write!(w, "TABLE_LIST[{}] =", index)?;
+			write_table_init(v.limits(), w)?;
+		}
+
+		Ok(())
+	}
+
+	fn gen_memory_list(&self, w: Writer) -> Result<()> {
+		let memory = match self.wasm.memory_section() {
+			Some(v) => v.entries(),
+			None => return Ok(()),
+		};
+		let offset = self.wasm.import_count(ImportCountType::Memory);
+
+		for (i, v) in memory.iter().enumerate() {
+			let index = i + offset;
+
+			write!(w, "MEMORY_LIST[{}] =", index)?;
+			write_memory_init(v.limits(), w)?;
+		}
+
+		Ok(())
+	}
+
+	fn gen_global_list(&self, w: Writer) -> Result<()> {
+		let global = match self.wasm.global_section() {
+			Some(v) => v,
+			None => return Ok(()),
+		};
+		let offset = self.wasm.import_count(ImportCountType::Global);
+
+		for (i, v) in global.entries().iter().enumerate() {
+			let index = i + offset;
+
+			write!(w, "GLOBAL_LIST[{}] = {{ value =", index)?;
+
+			write_expression(v.init_expr().code(), w)?;
+
+			write!(w, "}}")?;
+		}
+
+		Ok(())
+	}
+
+	fn gen_element_list(&self, w: Writer) -> Result<()> {
+		let element = match self.wasm.elements_section() {
+			Some(v) => v.entries(),
+			None => return Ok(()),
+		};
+
+		for v in element {
+			write!(w, "do ")?;
+			write!(w, "local target = TABLE_LIST[{}].data ", v.index())?;
+			write!(w, "local offset =")?;
+
+			write_expression(v.offset().as_ref().unwrap().code(), w)?;
+
+			write!(w, "local data = {{")?;
+
+			v.members()
+				.iter()
+				.try_for_each(|v| write!(w, "FUNC_LIST[{}],", v))?;
+
+			write!(w, "}}")?;
+
+			write!(w, "table.move(data, 1, #data, offset, target)")?;
+
+			write!(w, "end ")?;
+		}
+
+		Ok(())
+	}
+
+	fn gen_data_list(&self, w: Writer) -> Result<()> {
+		let data = match self.wasm.data_section() {
+			Some(v) => v.entries(),
+			None => return Ok(()),
+		};
+
+		for v in data {
+			write!(w, "do ")?;
+			write!(w, "local target = MEMORY_LIST[{}]", v.index())?;
+			write!(w, "local offset =")?;
+
+			write_expression(v.offset().as_ref().unwrap().code(), w)?;
+
+			write!(w, "local data = \"")?;
+
+			v.value()
+				.iter()
+				.try_for_each(|v| write!(w, "\\x{:02X}", v))?;
+
+			write!(w, "\"")?;
+
+			write!(w, "rt.allocator.init(target, offset, data)")?;
+
+			write!(w, "end ")?;
+		}
+
+		Ok(())
+	}
+
+	fn gen_start_point(&self, w: Writer) -> Result<()> {
+		write!(w, "local function run_init_code()")?;
+		self.gen_table_list(w)?;
+		self.gen_memory_list(w)?;
+		self.gen_global_list(w)?;
+		self.gen_element_list(w)?;
+		self.gen_data_list(w)?;
+		write!(w, "end ")?;
+
+		write!(w, "return function(wasm)")?;
+		self.gen_import_list(w)?;
+		write!(w, "run_init_code()")?;
+
+		if let Some(start) = self.wasm.start_section() {
+			write!(w, "FUNC_LIST[{}]()", start)?;
+		}
+
+		write!(w, "return {{")?;
+		self.gen_export_list(w)?;
+		write!(w, "}} end ")
+	}
+
+	fn gen_localize(func_list: &[Function], w: Writer) -> Result<()> {
+		let mut loc_set = BTreeSet::new();
+
+		for func in func_list {
+			loc_set.extend(localize::visit(func));
+		}
+
+		loc_set
+			.into_iter()
+			.try_for_each(|(a, b)| write!(w, "local {0}_{1} = rt.{0}.{1} ", a, b))
+	}
+
+	// FIXME: Make `pub` only for fuzzing.
+	#[must_use]
+	pub fn build_func_list(&self) -> Vec<Function> {
+		let range = 0..self.arity.len_in();
+
+		range
+			.map(|i| Builder::new(self.wasm, &self.arity).consume(i))
+			.collect()
+	}
+
+	/// # Errors
+	/// Returns `Err` if writing to `Writer` failed.
+	///
+	/// # Panics
+	/// If the number of functions overflows 32 bits.
+	pub fn gen_func_list(&self, func_list: &[Function], w: Writer) -> Result<()> {
+		let o = self.arity.len_ex();
+
+		func_list.iter().enumerate().try_for_each(|(i, v)| {
+			write_func_name(self.wasm, i.try_into().unwrap(), o.try_into().unwrap(), w)?;
+
+			v.visit(&mut Visitor::default(), w)
+		})
+	}
+}

codegen-luajit/src/lib.rs

@@ -0,0 +1,4 @@
+pub static RUNTIME: &str = include_str!("../runtime/runtime.lua");
+
+mod analyzer;
+pub mod gen;