Refactor Builder behavior and stack emulation

wasm-ast/src/builder.rs

@@ -99,103 +99,16 @@ impl Arities {
 	}
 }
 
-pub struct Builder<'a> {
+#[derive(Default)]
-	// target state
+struct Stacked {
-	wasm: &'a Module,
+	pending_list: Vec<Vec<Expression>>,
-	other: &'a Arities,
-	num_result: u32,
-
-	// translation state
-	pending: Vec<Vec<Expression>>,
 	stack: Vec<Expression>,
 	last_stack: usize,
 }
 
-fn is_else_stat(inst: &Instruction) -> bool {
+impl Stacked {
-	inst == &Instruction::Else
+	fn new() -> Self {
-}
+		Self::default()
-
-fn is_dead_precursor(inst: &Instruction) -> bool {
-	matches!(
-		inst,
-		Instruction::Unreachable | Instruction::Br(_) | Instruction::Return
-	)
-}
-
-fn flat_local_list(local: Local) -> impl Iterator<Item = ValueType> {
-	std::iter::repeat(local.value_type()).take(local.count().try_into().unwrap())
-}
-
-fn load_local_list(func: &FuncBody) -> Vec<ValueType> {
-	func.locals()
-		.iter()
-		.copied()
-		.flat_map(flat_local_list)
-		.collect()
-}
-
-fn load_func_at(wasm: &Module, index: usize) -> &FuncBody {
-	&wasm.code_section().unwrap().bodies()[index]
-}
-
-impl<'a> Builder<'a> {
-	#[must_use]
-	pub fn new(wasm: &'a Module, other: &'a Arities) -> Builder<'a> {
-		Builder {
-			wasm,
-			other,
-			num_result: 0,
-			pending: Vec::new(),
-			stack: Vec::new(),
-			last_stack: 0,
-		}
-	}
-
-	#[must_use]
-	pub fn consume(mut self, index: usize) -> Function {
-		let func = load_func_at(self.wasm, index);
-		let arity = &self.other.in_arity[index];
-
-		let local_list = load_local_list(func);
-		let num_param = arity.num_param;
-
-		self.num_result = arity.num_result;
-
-		let body = self.new_forward(&mut func.code().elements());
-		let num_stack = self.last_stack.try_into().unwrap();
-
-		Function {
-			local_list,
-			num_param,
-			num_stack,
-			body,
-		}
-	}
-
-	fn get_type_of(&self, index: u32) -> Arity {
-		let types = self.wasm.type_section().unwrap().types();
-
-		Arity::from_index(types, index)
-	}
-
-	fn push_recall(&mut self, num: u32) {
-		let len = self.stack.len();
-
-		for var in len..len + num as usize {
-			self.stack.push(Expression::Recall(Recall { var }));
-		}
-	}
-
-	fn push_block_result(&mut self, typ: BlockType) {
-		let num = match typ {
-			BlockType::NoResult => {
-				return;
-			}
-			BlockType::Value(_) => 1,
-			BlockType::TypeIndex(i) => self.get_type_of(i).num_result,
-		};
-
-		self.push_recall(num);
 	}
 
 	// If any expressions are still pending at the start of
@@ -226,63 +139,35 @@ impl<'a> Builder<'a> {
 	fn save_pending(&mut self) {
 		let cloned = self.stack.iter().map(Expression::clone_recall).collect();
 
-		self.pending.push(cloned);
+		self.pending_list.push(cloned);
 	}
 
 	fn load_pending(&mut self) {
-		self.stack = self.pending.pop().unwrap();
+		self.stack = self.pending_list.pop().unwrap();
 	}
 
-	fn gen_return(&mut self, stat: &mut Vec<Statement>) {
+	fn pop(&mut self) -> Expression {
-		let num = self.num_result as usize;
+		self.stack.pop().unwrap()
-		let list = self.stack.split_off(self.stack.len() - num);
-
-		self.gen_leak_pending(stat);
-		stat.push(Statement::Return(Return { list }));
 	}
 
-	fn gen_call(&mut self, func: u32, stat: &mut Vec<Statement>) {
+	fn push(&mut self, value: Expression) {
-		let arity = self.other.arity_of(func as usize);
+		self.stack.push(value);
-
-		let param_list = self
-			.stack
-			.split_off(self.stack.len() - arity.num_param as usize);
-
-		let len = u32::try_from(self.stack.len()).unwrap();
-		let result = len..len + arity.num_result;
-
-		self.push_recall(arity.num_result);
-		self.gen_leak_pending(stat);
-		stat.push(Statement::Call(Call {
-			func,
-			result,
-			param_list,
-		}));
 	}
 
-	fn gen_call_indirect(&mut self, typ: u32, table: u8, stat: &mut Vec<Statement>) {
+	fn push_constant(&mut self, value: Value) {
-		let arity = self.get_type_of(typ);
+		self.stack.push(Expression::Value(value));
+	}
 
-		let index = self.stack.pop().unwrap();
+	fn push_recall(&mut self, num: u32) {
-		let param_list = self
+		let len = self.stack.len();
-			.stack
-			.split_off(self.stack.len() - arity.num_param as usize);
 
-		let len = u32::try_from(self.stack.len()).unwrap();
+		for var in len..len + num as usize {
-		let result = len..len + arity.num_result;
+			self.stack.push(Expression::Recall(Recall { var }));
-
+		}
-		self.push_recall(arity.num_result);
-		self.gen_leak_pending(stat);
-		stat.push(Statement::CallIndirect(CallIndirect {
-			table,
-			index,
-			result,
-			param_list,
-		}));
 	}
 
 	fn push_load(&mut self, op: Load, offset: u32) {
-		let pointer = Box::new(self.stack.pop().unwrap());
+		let pointer = Box::new(self.pop());
 
 		self.stack.push(Expression::AnyLoad(AnyLoad {
 			op,
@@ -292,10 +177,11 @@ impl<'a> Builder<'a> {
 	}
 
 	fn gen_store(&mut self, op: Store, offset: u32, stat: &mut Vec<Statement>) {
-		let value = self.stack.pop().unwrap();
+		let value = self.pop();
-		let pointer = self.stack.pop().unwrap();
+		let pointer = self.pop();
 
 		self.gen_leak_pending(stat);
+
 		stat.push(Statement::AnyStore(AnyStore {
 			op,
 			offset,
@@ -304,27 +190,23 @@ impl<'a> Builder<'a> {
 		}));
 	}
 
-	fn push_constant(&mut self, value: Value) {
-		self.stack.push(Expression::Value(value));
-	}
-
 	fn push_un_op(&mut self, op: UnOp) {
-		let rhs = Box::new(self.stack.pop().unwrap());
+		let rhs = Box::new(self.pop());
 
 		self.stack.push(Expression::AnyUnOp(AnyUnOp { op, rhs }));
 	}
 
 	fn push_bin_op(&mut self, op: BinOp) {
-		let rhs = Box::new(self.stack.pop().unwrap());
+		let rhs = Box::new(self.pop());
-		let lhs = Box::new(self.stack.pop().unwrap());
+		let lhs = Box::new(self.pop());
 
 		self.stack
 			.push(Expression::AnyBinOp(AnyBinOp { op, lhs, rhs }));
 	}
 
 	fn push_cmp_op(&mut self, op: CmpOp) {
-		let rhs = Box::new(self.stack.pop().unwrap());
+		let rhs = Box::new(self.pop());
-		let lhs = Box::new(self.stack.pop().unwrap());
+		let lhs = Box::new(self.pop());
 
 		self.stack
 			.push(Expression::AnyCmpOp(AnyCmpOp { op, lhs, rhs }));
@@ -367,6 +249,142 @@ impl<'a> Builder<'a> {
 			self.from_equal_zero(inst)
 		}
 	}
+}
+
+pub struct Builder<'a> {
+	// target state
+	wasm: &'a Module,
+	other: &'a Arities,
+	num_result: u32,
+
+	// translation state
+	data: Stacked,
+}
+
+fn is_else_stat(inst: &Instruction) -> bool {
+	inst == &Instruction::Else
+}
+
+fn is_dead_precursor(inst: &Instruction) -> bool {
+	matches!(
+		inst,
+		Instruction::Unreachable | Instruction::Br(_) | Instruction::Return
+	)
+}
+
+fn flat_local_list(local: Local) -> impl Iterator<Item = ValueType> {
+	std::iter::repeat(local.value_type()).take(local.count().try_into().unwrap())
+}
+
+fn load_local_list(func: &FuncBody) -> Vec<ValueType> {
+	func.locals()
+		.iter()
+		.copied()
+		.flat_map(flat_local_list)
+		.collect()
+}
+
+fn load_func_at(wasm: &Module, index: usize) -> &FuncBody {
+	&wasm.code_section().unwrap().bodies()[index]
+}
+
+impl<'a> Builder<'a> {
+	#[must_use]
+	pub fn new(wasm: &'a Module, other: &'a Arities) -> Builder<'a> {
+		Builder {
+			wasm,
+			other,
+			num_result: 0,
+			data: Stacked::new(),
+		}
+	}
+
+	#[must_use]
+	pub fn consume(mut self, index: usize) -> Function {
+		let func = load_func_at(self.wasm, index);
+		let arity = &self.other.in_arity[index];
+
+		let local_list = load_local_list(func);
+		let num_param = arity.num_param;
+
+		self.num_result = arity.num_result;
+
+		let body = self.new_forward(&mut func.code().elements());
+		let num_stack = self.data.last_stack.try_into().unwrap();
+
+		Function {
+			local_list,
+			num_param,
+			num_stack,
+			body,
+		}
+	}
+
+	fn get_type_of(&self, index: u32) -> Arity {
+		let types = self.wasm.type_section().unwrap().types();
+
+		Arity::from_index(types, index)
+	}
+
+	fn push_block_result(&mut self, typ: BlockType) {
+		let num = match typ {
+			BlockType::NoResult => {
+				return;
+			}
+			BlockType::Value(_) => 1,
+			BlockType::TypeIndex(i) => self.get_type_of(i).num_result,
+		};
+
+		self.data.push_recall(num);
+	}
+
+	fn gen_return(&mut self, stat: &mut Vec<Statement>) {
+		let num = self.num_result as usize;
+		let list = self.data.stack.split_off(self.data.stack.len() - num);
+
+		self.data.gen_leak_pending(stat);
+
+		stat.push(Statement::Return(Return { list }));
+	}
+
+	fn gen_call(&mut self, func: u32, stat: &mut Vec<Statement>) {
+		let arity = self.other.arity_of(func as usize);
+		let len = self.data.stack.len();
+
+		let first = u32::try_from(len).unwrap();
+		let result = first..first + arity.num_result;
+		let param_list = self.data.stack.split_off(len - arity.num_param as usize);
+
+		self.data.push_recall(arity.num_result);
+		self.data.gen_leak_pending(stat);
+
+		stat.push(Statement::Call(Call {
+			func,
+			result,
+			param_list,
+		}));
+	}
+
+	fn gen_call_indirect(&mut self, typ: u32, table: u8, stat: &mut Vec<Statement>) {
+		let arity = self.get_type_of(typ);
+		let len = self.data.stack.len();
+
+		let index = self.data.pop();
+		let param_list = self.data.stack.split_off(len - arity.num_param as usize);
+
+		let first = u32::try_from(len).unwrap();
+		let result = first..first + arity.num_result;
+
+		self.data.push_recall(arity.num_result);
+		self.data.gen_leak_pending(stat);
+
+		stat.push(Statement::CallIndirect(CallIndirect {
+			table,
+			index,
+			result,
+			param_list,
+		}));
+	}
 
 	fn drop_unreachable(list: &mut &[Instruction]) {
 		use Instruction as Inst;
@@ -405,14 +423,14 @@ impl<'a> Builder<'a> {
 
 		let mut stat = Vec::new();
 
-		self.save_pending();
+		self.data.save_pending();
 
 		loop {
 			let inst = &list[0];
 
 			*list = &list[1..];
 
-			if self.from_operation(inst) {
+			if self.data.from_operation(inst) {
 				continue;
 			}
 
@@ -422,7 +440,7 @@ impl<'a> Builder<'a> {
 					stat.push(Statement::Unreachable);
 				}
 				Inst::Block(t) => {
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 
 					let data = self.new_forward(list);
 
@@ -430,7 +448,7 @@ impl<'a> Builder<'a> {
 					stat.push(Statement::Forward(data));
 				}
 				Inst::Loop(t) => {
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 
 					let data = self.new_backward(list);
 
@@ -438,9 +456,9 @@ impl<'a> Builder<'a> {
 					stat.push(Statement::Backward(data));
 				}
 				Inst::If(t) => {
-					let cond = self.stack.pop().unwrap();
+					let cond = self.data.pop();
 
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 
 					let data = self.new_if(cond, list);
 
@@ -448,7 +466,7 @@ impl<'a> Builder<'a> {
 					stat.push(Statement::If(data));
 				}
 				Inst::Else => {
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 
 					break;
 				}
@@ -456,25 +474,25 @@ impl<'a> Builder<'a> {
 					if list.is_empty() && self.num_result != 0 {
 						self.gen_return(&mut stat);
 					} else {
-						self.gen_leak_pending(&mut stat);
+						self.data.gen_leak_pending(&mut stat);
 					}
 
 					break;
 				}
 				Inst::Br(i) => {
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 					stat.push(Statement::Br(Br { target: *i }));
 				}
 				Inst::BrIf(i) => {
-					let cond = self.stack.pop().unwrap();
+					let cond = self.data.pop();
 
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 					stat.push(Statement::BrIf(BrIf { cond, target: *i }));
 				}
 				Inst::BrTable(t) => {
-					let cond = self.stack.pop().unwrap();
+					let cond = self.data.pop();
 
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 					stat.push(Statement::BrTable(BrTable {
 						cond,
 						data: *t.clone(),
@@ -490,80 +508,80 @@ impl<'a> Builder<'a> {
 					self.gen_call_indirect(*i, *t, &mut stat);
 				}
 				Inst::Drop => {
-					self.stack.pop().unwrap();
+					self.data.pop();
 				}
 				Inst::Select => {
-					let cond = Box::new(self.stack.pop().unwrap());
+					let cond = Box::new(self.data.pop());
-					let b = Box::new(self.stack.pop().unwrap());
+					let b = Box::new(self.data.pop());
-					let a = Box::new(self.stack.pop().unwrap());
+					let a = Box::new(self.data.pop());
 
-					self.stack.push(Expression::Select(Select { cond, a, b }));
+					self.data.push(Expression::Select(Select { cond, a, b }));
 				}
 				Inst::GetLocal(i) => {
-					self.stack.push(Expression::GetLocal(GetLocal { var: *i }));
+					self.data.push(Expression::GetLocal(GetLocal { var: *i }));
 				}
 				Inst::SetLocal(i) => {
-					let value = self.stack.pop().unwrap();
+					let value = self.data.pop();
 
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 					stat.push(Statement::SetLocal(SetLocal { var: *i, value }));
 				}
 				Inst::TeeLocal(i) => {
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 
-					let value = self.stack.last().unwrap().clone_recall();
+					let value = self.data.pop();
 
+					self.data.push(value.clone_recall());
 					stat.push(Statement::SetLocal(SetLocal { var: *i, value }));
 				}
 				Inst::GetGlobal(i) => {
-					self.stack
+					self.data.push(Expression::GetGlobal(GetGlobal { var: *i }));
-						.push(Expression::GetGlobal(GetGlobal { var: *i }));
 				}
 				Inst::SetGlobal(i) => {
-					let value = self.stack.pop().unwrap();
+					let value = self.data.pop();
 
 					stat.push(Statement::SetGlobal(SetGlobal { var: *i, value }));
 				}
-				Inst::I32Load(_, o) => self.push_load(Load::I32, *o),
+				Inst::I32Load(_, o) => self.data.push_load(Load::I32, *o),
-				Inst::I64Load(_, o) => self.push_load(Load::I64, *o),
+				Inst::I64Load(_, o) => self.data.push_load(Load::I64, *o),
-				Inst::F32Load(_, o) => self.push_load(Load::F32, *o),
+				Inst::F32Load(_, o) => self.data.push_load(Load::F32, *o),
-				Inst::F64Load(_, o) => self.push_load(Load::F64, *o),
+				Inst::F64Load(_, o) => self.data.push_load(Load::F64, *o),
-				Inst::I32Load8S(_, o) => self.push_load(Load::I32_I8, *o),
+				Inst::I32Load8S(_, o) => self.data.push_load(Load::I32_I8, *o),
-				Inst::I32Load8U(_, o) => self.push_load(Load::I32_U8, *o),
+				Inst::I32Load8U(_, o) => self.data.push_load(Load::I32_U8, *o),
-				Inst::I32Load16S(_, o) => self.push_load(Load::I32_I16, *o),
+				Inst::I32Load16S(_, o) => self.data.push_load(Load::I32_I16, *o),
-				Inst::I32Load16U(_, o) => self.push_load(Load::I32_U16, *o),
+				Inst::I32Load16U(_, o) => self.data.push_load(Load::I32_U16, *o),
-				Inst::I64Load8S(_, o) => self.push_load(Load::I64_I8, *o),
+				Inst::I64Load8S(_, o) => self.data.push_load(Load::I64_I8, *o),
-				Inst::I64Load8U(_, o) => self.push_load(Load::I64_U8, *o),
+				Inst::I64Load8U(_, o) => self.data.push_load(Load::I64_U8, *o),
-				Inst::I64Load16S(_, o) => self.push_load(Load::I64_I16, *o),
+				Inst::I64Load16S(_, o) => self.data.push_load(Load::I64_I16, *o),
-				Inst::I64Load16U(_, o) => self.push_load(Load::I64_U16, *o),
+				Inst::I64Load16U(_, o) => self.data.push_load(Load::I64_U16, *o),
-				Inst::I64Load32S(_, o) => self.push_load(Load::I64_I32, *o),
+				Inst::I64Load32S(_, o) => self.data.push_load(Load::I64_I32, *o),
-				Inst::I64Load32U(_, o) => self.push_load(Load::I64_U32, *o),
+				Inst::I64Load32U(_, o) => self.data.push_load(Load::I64_U32, *o),
-				Inst::I32Store(_, o) => self.gen_store(Store::I32, *o, &mut stat),
+				Inst::I32Store(_, o) => self.data.gen_store(Store::I32, *o, &mut stat),
-				Inst::I64Store(_, o) => self.gen_store(Store::I64, *o, &mut stat),
+				Inst::I64Store(_, o) => self.data.gen_store(Store::I64, *o, &mut stat),
-				Inst::F32Store(_, o) => self.gen_store(Store::F32, *o, &mut stat),
+				Inst::F32Store(_, o) => self.data.gen_store(Store::F32, *o, &mut stat),
-				Inst::F64Store(_, o) => self.gen_store(Store::F64, *o, &mut stat),
+				Inst::F64Store(_, o) => self.data.gen_store(Store::F64, *o, &mut stat),
-				Inst::I32Store8(_, o) => self.gen_store(Store::I32_N8, *o, &mut stat),
+				Inst::I32Store8(_, o) => self.data.gen_store(Store::I32_N8, *o, &mut stat),
-				Inst::I32Store16(_, o) => self.gen_store(Store::I32_N16, *o, &mut stat),
+				Inst::I32Store16(_, o) => self.data.gen_store(Store::I32_N16, *o, &mut stat),
-				Inst::I64Store8(_, o) => self.gen_store(Store::I64_N8, *o, &mut stat),
+				Inst::I64Store8(_, o) => self.data.gen_store(Store::I64_N8, *o, &mut stat),
-				Inst::I64Store16(_, o) => self.gen_store(Store::I64_N16, *o, &mut stat),
+				Inst::I64Store16(_, o) => self.data.gen_store(Store::I64_N16, *o, &mut stat),
-				Inst::I64Store32(_, o) => self.gen_store(Store::I64_N32, *o, &mut stat),
+				Inst::I64Store32(_, o) => self.data.gen_store(Store::I64_N32, *o, &mut stat),
 				Inst::CurrentMemory(i) => {
-					self.stack
+					self.data
 						.push(Expression::MemorySize(MemorySize { memory: *i }));
 				}
 				Inst::GrowMemory(i) => {
-					let value = Box::new(self.stack.pop().unwrap());
+					let value = Box::new(self.data.pop());
 
 					// `MemoryGrow` is an expression *but* it has side effects
-					self.stack
+					self.data
 						.push(Expression::MemoryGrow(MemoryGrow { memory: *i, value }));
 
-					self.gen_leak_pending(&mut stat);
+					self.data.gen_leak_pending(&mut stat);
 				}
-				Inst::I32Const(v) => self.push_constant(Value::I32(*v)),
+				Inst::I32Const(v) => self.data.push_constant(Value::I32(*v)),
-				Inst::I64Const(v) => self.push_constant(Value::I64(*v)),
+				Inst::I64Const(v) => self.data.push_constant(Value::I64(*v)),
-				Inst::F32Const(v) => self.push_constant(Value::F32(f32::from_bits(*v))),
+				Inst::F32Const(v) => self.data.push_constant(Value::F32(f32::from_bits(*v))),
-				Inst::F64Const(v) => self.push_constant(Value::F64(f64::from_bits(*v))),
+				Inst::F64Const(v) => self.data.push_constant(Value::F64(f64::from_bits(*v))),
 				_ => unreachable!(),
 			}
 
@@ -574,7 +592,7 @@ impl<'a> Builder<'a> {
 			}
 		}
 
-		self.load_pending();
+		self.data.load_pending();
 
 		stat
 	}