Restructure and compartmentalize the project

2022-06-23 20:14:04 -04:00
parent 59a5a3219f
commit 223895e617
34 changed files with 105 additions and 93 deletions
@@ -0,0 +1,173 @@
+use std::{
+	io::{Result, Write},
+	num::FpCategory,
+};
+
+use wasm_ast::node::{
+	BinOp, CmpOp, Expression, GetGlobal, GetLocal, GetTemporary, LoadAt, MemorySize, Select, UnOp,
+	Value,
+};
+
+use crate::analyzer::as_symbol::AsSymbol;
+
+use super::manager::{
+	write_cmp_op, write_condition, write_separated, write_variable, Driver, Manager,
+};
+
+macro_rules! impl_write_number {
+	($name:tt, $numeric:ty) => {
+		fn $name(number: $numeric, w: &mut dyn Write) -> Result<()> {
+			match (number.classify(), number.is_sign_negative()) {
+				(FpCategory::Nan, true) => write!(w, "(0.0 / 0.0) "),
+				(FpCategory::Nan, false) => write!(w, "-(0.0 / 0.0) "),
+				(FpCategory::Infinite, true) => write!(w, "-math.huge "),
+				(FpCategory::Infinite, false) => write!(w, "math.huge "),
+				_ => write!(w, "{number:e} "),
+			}
+		}
+	};
+}
+
+impl Driver for Select {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "(")?;
+		write_condition(self.condition(), mng, w)?;
+		write!(w, "and ")?;
+		self.on_true().write(mng, w)?;
+		write!(w, "or ")?;
+		self.on_false().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for GetTemporary {
+	fn write(&self, _: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "reg_{} ", self.var())
+	}
+}
+
+impl Driver for GetLocal {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write_variable(self.var(), mng, w)
+	}
+}
+
+impl Driver for GetGlobal {
+	fn write(&self, _: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "GLOBAL_LIST[{}].value ", self.var())
+	}
+}
+
+impl Driver for LoadAt {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "load_{}(memory_at_0, ", self.load_type().as_name())?;
+		self.pointer().write(mng, w)?;
+
+		if self.offset() != 0 {
+			write!(w, "+ {}", self.offset())?;
+		}
+
+		write!(w, ")")
+	}
+}
+
+impl Driver for MemorySize {
+	fn write(&self, _: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "memory_at_{}.min ", self.memory())
+	}
+}
+
+pub fn write_i32(number: i32, w: &mut dyn Write) -> Result<()> {
+	let list = number.to_ne_bytes();
+
+	write!(w, "{} ", u32::from_ne_bytes(list))
+}
+
+fn write_i64(number: i64, w: &mut dyn Write) -> Result<()> {
+	match number {
+		0 => write!(w, "i64_K_ZERO "),
+		1 => write!(w, "i64_K_ONE "),
+		_ => {
+			let list = number.to_ne_bytes();
+			let a = u32::from_ne_bytes(list[0..4].try_into().unwrap());
+			let b = u32::from_ne_bytes(list[4..8].try_into().unwrap());
+
+			write!(w, "i64_from_u32({a}, {b}) ")
+		}
+	}
+}
+
+impl_write_number!(write_f32, f32);
+impl_write_number!(write_f64, f64);
+
+impl Driver for Value {
+	fn write(&self, _: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		match self {
+			Self::I32(i) => write_i32(*i, w),
+			Self::I64(i) => write_i64(*i, w),
+			Self::F32(f) => write_f32(*f, w),
+			Self::F64(f) => write_f64(*f, w),
+		}
+	}
+}
+
+impl Driver for UnOp {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		let (a, b) = self.op_type().as_name();
+
+		write!(w, "{a}_{b}(")?;
+		self.rhs().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for BinOp {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		if let Some(symbol) = self.op_type().as_symbol() {
+			write!(w, "(")?;
+			self.lhs().write(mng, w)?;
+			write!(w, "{symbol} ")?;
+			self.rhs().write(mng, w)?;
+			write!(w, ")")
+		} else {
+			let (head, tail) = self.op_type().as_name();
+
+			write!(w, "{head}_{tail}(")?;
+			self.lhs().write(mng, w)?;
+			write!(w, ", ")?;
+			self.rhs().write(mng, w)?;
+			write!(w, ")")
+		}
+	}
+}
+
+impl Driver for CmpOp {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "(")?;
+		write_cmp_op(self, mng, w)?;
+		write!(w, "and 1 or 0)")
+	}
+}
+
+impl Driver for Expression {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		match self {
+			Self::Select(e) => e.write(mng, w),
+			Self::GetTemporary(e) => e.write(mng, w),
+			Self::GetLocal(e) => e.write(mng, w),
+			Self::GetGlobal(e) => e.write(mng, w),
+			Self::LoadAt(e) => e.write(mng, w),
+			Self::MemorySize(e) => e.write(mng, w),
+			Self::Value(e) => e.write(mng, w),
+			Self::UnOp(e) => e.write(mng, w),
+			Self::BinOp(e) => e.write(mng, w),
+			Self::CmpOp(e) => e.write(mng, w),
+		}
+	}
+}
+
+impl Driver for &[Expression] {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write_separated(self.iter(), |e, w| e.write(mng, w), w)
+	}
+}
@@ -0,0 +1,109 @@
+use std::{
+	collections::HashMap,
+	io::{Result, Write},
+	ops::Range,
+};
+
+use wasm_ast::node::{BrTable, CmpOp, Expression};
+
+use crate::analyzer::as_symbol::AsSymbol;
+
+#[derive(PartialEq, Eq)]
+pub enum Label {
+	Forward,
+	Backward,
+}
+
+#[derive(Default)]
+pub struct Manager {
+	table_map: HashMap<usize, usize>,
+	label_list: Vec<Label>,
+	num_param: usize,
+}
+
+impl Manager {
+	pub fn get_table_index(&self, table: &BrTable) -> usize {
+		let id = table as *const _ as usize;
+
+		self.table_map[&id]
+	}
+
+	pub fn set_table_map(&mut self, map: HashMap<usize, usize>) {
+		self.table_map = map;
+	}
+
+	pub fn set_num_param(&mut self, num_param: usize) {
+		self.num_param = num_param;
+	}
+
+	pub fn label_list(&self) -> &[Label] {
+		&self.label_list
+	}
+
+	pub fn push_label(&mut self, label: Label) -> usize {
+		self.label_list.push(label);
+
+		self.label_list.len() - 1
+	}
+
+	pub fn pop_label(&mut self) {
+		self.label_list.pop().unwrap();
+	}
+}
+
+pub trait Driver {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()>;
+}
+
+pub fn write_separated<I, T, M>(mut iter: I, mut func: M, w: &mut dyn Write) -> Result<()>
+where
+	M: FnMut(T, &mut dyn Write) -> Result<()>,
+	I: Iterator<Item = T>,
+{
+	match iter.next() {
+		Some(first) => func(first, w)?,
+		None => return Ok(()),
+	}
+
+	iter.try_for_each(|v| {
+		write!(w, ", ")?;
+		func(v, w)
+	})
+}
+
+pub fn write_ascending(prefix: &str, range: Range<usize>, w: &mut dyn Write) -> Result<()> {
+	write_separated(range, |i, w| write!(w, "{prefix}_{i}"), w)
+}
+
+pub fn write_variable(var: usize, mng: &Manager, w: &mut dyn Write) -> Result<()> {
+	if let Some(rem) = var.checked_sub(mng.num_param) {
+		write!(w, "loc_{rem} ")
+	} else {
+		write!(w, "param_{var} ")
+	}
+}
+
+pub fn write_cmp_op(cmp: &CmpOp, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+	if let Some(symbol) = cmp.op_type().as_symbol() {
+		cmp.lhs().write(mng, w)?;
+		write!(w, "{symbol} ")?;
+		cmp.rhs().write(mng, w)
+	} else {
+		let (head, tail) = cmp.op_type().as_name();
+
+		write!(w, "{head}_{tail}(")?;
+		cmp.lhs().write(mng, w)?;
+		write!(w, ", ")?;
+		cmp.rhs().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+pub fn write_condition(data: &Expression, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+	if let Expression::CmpOp(node) = data {
+		write_cmp_op(node, mng, w)
+	} else {
+		data.write(mng, w)?;
+		write!(w, "~= 0 ")
+	}
+}
@@ -0,0 +1,4 @@
+pub mod manager;
+
+mod expression;
+mod statement;
@@ -0,0 +1,380 @@
+use std::{
+	io::{Result, Write},
+	ops::Range,
+};
+
+use parity_wasm::elements::ValueType;
+use wasm_ast::node::{
+	Backward, Br, BrIf, BrTable, Call, CallIndirect, Forward, FuncData, If, MemoryGrow, SetGlobal,
+	SetLocal, SetTemporary, Statement, StoreAt, Terminator,
+};
+
+use crate::analyzer::br_table;
+
+use super::manager::{
+	write_ascending, write_condition, write_separated, write_variable, Driver, Label, Manager,
+};
+
+impl Driver for Br {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		if !self.align().is_aligned() {
+			write_ascending("reg", self.align().new_range(), w)?;
+			write!(w, " = ")?;
+			write_ascending("reg", self.align().old_range(), w)?;
+			write!(w, " ")?;
+		}
+
+		if self.target() == 0 {
+			if let Some(&Label::Backward) = mng.label_list().last() {
+				write!(w, "continue ")?;
+			} else {
+				write!(w, "break ")?;
+			}
+		} else {
+			let level = mng.label_list().len() - 1 - self.target();
+
+			write!(w, "desired = {level} ")?;
+			write!(w, "break ")?;
+		}
+
+		Ok(())
+	}
+}
+
+fn to_ordered_table<'a>(list: &'a [Br], default: &'a Br) -> Vec<&'a Br> {
+	let mut data: Vec<_> = list.iter().chain(std::iter::once(default)).collect();
+
+	data.sort_by_key(|v| v.target());
+	data.dedup_by_key(|v| v.target());
+
+	data
+}
+
+fn write_search_layer(
+	range: Range<usize>,
+	list: &[&Br],
+	mng: &mut Manager,
+	w: &mut dyn Write,
+) -> Result<()> {
+	if range.len() == 1 {
+		return list[range.start].write(mng, w);
+	}
+
+	let center = range.start + range.len() / 2;
+	let br = list[center];
+
+	if range.start != center {
+		write!(w, "if temp < {} then ", br.target())?;
+		write_search_layer(range.start..center, list, mng, w)?;
+		write!(w, "else")?;
+	}
+
+	if range.end != center + 1 {
+		write!(w, "if temp > {} then ", br.target())?;
+		write_search_layer(center + 1..range.end, list, mng, w)?;
+		write!(w, "else")?;
+	}
+
+	write!(w, " ")?;
+	br.write(mng, w)?;
+	write!(w, "end ")
+}
+
+fn write_table_setup(table: &BrTable, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+	let id = mng.get_table_index(table);
+
+	write!(w, "if not br_map[{id}] then ")?;
+	write!(w, "br_map[{id}] = (function() return {{[0] =")?;
+
+	table
+		.data()
+		.iter()
+		.try_for_each(|v| write!(w, "{},", v.target()))?;
+
+	write!(w, "}} end)()")?;
+	write!(w, "end ")?;
+
+	write!(w, "local temp = br_map[{id}][")?;
+	table.condition().write(mng, w)?;
+	write!(w, "] or {} ", table.default().target())
+}
+
+impl Driver for BrTable {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		if self.data().is_empty() {
+			// Our condition should be pure so we probably don't need
+			// to emit it in this case.
+			return self.default().write(mng, w);
+		}
+
+		// `BrTable` is optimized by first mapping all indices to targets through
+		// a Lua table; this reduces the size of the code generated as duplicate entries
+		// don't need checking. Then, for speed, a binary search is done for the target
+		// and the appropriate jump is performed.
+		let list = to_ordered_table(self.data(), self.default());
+
+		write_table_setup(self, mng, w)?;
+		write_search_layer(0..list.len(), &list, mng, w)
+	}
+}
+
+impl Driver for Terminator {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		match self {
+			Self::Unreachable => write!(w, "error(\"out of code bounds\")"),
+			Self::Br(s) => s.write(mng, w),
+			Self::BrTable(s) => s.write(mng, w),
+		}
+	}
+}
+
+fn br_target(level: usize, in_loop: bool, w: &mut dyn Write) -> Result<()> {
+	write!(w, "if desired then ")?;
+	write!(w, "if desired == {level} then ")?;
+	write!(w, "desired = nil ")?;
+
+	if in_loop {
+		write!(w, "continue ")?;
+	}
+
+	write!(w, "else ")?;
+	write!(w, "break ")?;
+	write!(w, "end ")?;
+	write!(w, "end ")
+}
+
+fn write_br_gadget(label_list: &[Label], rem: usize, w: &mut dyn Write) -> Result<()> {
+	match label_list.last() {
+		Some(Label::Forward) => br_target(rem, false, w),
+		Some(Label::Backward) => br_target(rem, true, w),
+		None => Ok(()),
+	}
+}
+
+impl Driver for Forward {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		let rem = mng.push_label(Label::Forward);
+
+		write!(w, "while true do ")?;
+
+		self.code().iter().try_for_each(|s| s.write(mng, w))?;
+
+		if let Some(v) = self.last() {
+			v.write(mng, w)?;
+		} else {
+			write!(w, "break ")?;
+		}
+
+		write!(w, "end ")?;
+
+		mng.pop_label();
+		write_br_gadget(mng.label_list(), rem, w)
+	}
+}
+
+impl Driver for Backward {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		let rem = mng.push_label(Label::Backward);
+
+		write!(w, "while true do ")?;
+
+		self.code().iter().try_for_each(|s| s.write(mng, w))?;
+
+		if let Some(v) = self.last() {
+			v.write(mng, w)?;
+		} else {
+			write!(w, "break ")?;
+		}
+
+		write!(w, "end ")?;
+
+		mng.pop_label();
+		write_br_gadget(mng.label_list(), rem, w)
+	}
+}
+
+impl Driver for BrIf {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "if ")?;
+		write_condition(self.condition(), mng, w)?;
+		write!(w, "then ")?;
+		self.target().write(mng, w)?;
+		write!(w, "end ")
+	}
+}
+
+impl Driver for If {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "if ")?;
+		write_condition(self.condition(), mng, w)?;
+		write!(w, "then ")?;
+
+		self.on_true().write(mng, w)?;
+
+		if let Some(v) = self.on_false() {
+			write!(w, "else ")?;
+
+			v.write(mng, w)?;
+		}
+
+		write!(w, "end ")
+	}
+}
+
+fn write_call_store(result: Range<usize>, w: &mut dyn Write) -> Result<()> {
+	if result.is_empty() {
+		return Ok(());
+	}
+
+	write_ascending("reg", result, w)?;
+	write!(w, " = ")
+}
+
+impl Driver for Call {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write_call_store(self.result(), w)?;
+
+		write!(w, "FUNC_LIST[{}](", self.function())?;
+		self.param_list().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for CallIndirect {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write_call_store(self.result(), w)?;
+
+		write!(w, "TABLE_LIST[{}].data[", self.table())?;
+		self.index().write(mng, w)?;
+		write!(w, "](")?;
+		self.param_list().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for SetTemporary {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "reg_{} = ", self.var())?;
+		self.value().write(mng, w)
+	}
+}
+
+impl Driver for SetLocal {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write_variable(self.var(), mng, w)?;
+		write!(w, "= ")?;
+		self.value().write(mng, w)
+	}
+}
+
+impl Driver for SetGlobal {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "GLOBAL_LIST[{}].value = ", self.var())?;
+		self.value().write(mng, w)
+	}
+}
+
+impl Driver for StoreAt {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		write!(w, "store_{}(memory_at_0, ", self.store_type().as_name())?;
+		self.pointer().write(mng, w)?;
+
+		if self.offset() != 0 {
+			write!(w, "+ {}", self.offset())?;
+		}
+
+		write!(w, ", ")?;
+		self.value().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for MemoryGrow {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		let result = self.result();
+		let memory = self.memory();
+
+		write!(w, "reg_{result} = rt.allocator.grow(memory_at_{memory}, ")?;
+		self.size().write(mng, w)?;
+		write!(w, ")")
+	}
+}
+
+impl Driver for Statement {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		match self {
+			Self::Forward(s) => s.write(mng, w),
+			Self::Backward(s) => s.write(mng, w),
+			Self::BrIf(s) => s.write(mng, w),
+			Self::If(s) => s.write(mng, w),
+			Self::Call(s) => s.write(mng, w),
+			Self::CallIndirect(s) => s.write(mng, w),
+			Self::SetTemporary(s) => s.write(mng, w),
+			Self::SetLocal(s) => s.write(mng, w),
+			Self::SetGlobal(s) => s.write(mng, w),
+			Self::StoreAt(s) => s.write(mng, w),
+			Self::MemoryGrow(s) => s.write(mng, w),
+		}
+	}
+}
+
+fn write_parameter_list(ast: &FuncData, w: &mut dyn Write) -> Result<()> {
+	write!(w, "function(")?;
+	write_ascending("param", 0..ast.num_param(), w)?;
+	write!(w, ")")
+}
+
+fn write_variable_list(ast: &FuncData, w: &mut dyn Write) -> Result<()> {
+	let mut total = 0;
+
+	for data in ast.local_data().iter().filter(|v| v.count() != 0) {
+		let range = total..total + usize::try_from(data.count()).unwrap();
+		let zero = if data.value_type() == ValueType::I64 {
+			"i64_K_ZERO "
+		} else {
+			"0 "
+		};
+
+		total = range.end;
+
+		write!(w, "local ")?;
+		write_ascending("loc", range.clone(), w)?;
+		write!(w, " = ")?;
+		write_separated(range, |_, w| w.write_all(zero.as_bytes()), w)?;
+		write!(w, " ")?;
+	}
+
+	if ast.num_stack() != 0 {
+		write!(w, "local ")?;
+		write_ascending("reg", 0..ast.num_stack(), w)?;
+		write!(w, " ")?;
+	}
+
+	Ok(())
+}
+
+impl Driver for FuncData {
+	fn write(&self, mng: &mut Manager, w: &mut dyn Write) -> Result<()> {
+		let br_map = br_table::visit(self);
+
+		write_parameter_list(self, w)?;
+		write_variable_list(self, w)?;
+		write!(w, "local desired ")?;
+
+		if !br_map.is_empty() {
+			write!(w, "local br_map = {{}} ")?;
+		}
+
+		mng.set_table_map(br_map);
+		mng.set_num_param(self.num_param());
+		self.code().write(mng, w)?;
+
+		if self.num_result() != 0 {
+			write!(w, "return ")?;
+			write_ascending("reg", 0..self.num_result(), w)?;
+			write!(w, " ")?;
+		}
+
+		write!(w, "end ")
+	}
+}