code002lover/Wasynth
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improve nomenclature for Transformer

Browse Source
This commit is contained in:
Rerumu 2021-11-26 15:02:11 -05:00
parent 83d3f16b42
commit 55df4c39ca
1 changed files with 45 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
src/backend/ast/transformer.rs
View File

@ -22,8 +22,8 @@ pub struct Transformer<'a> {
name: usize, name: usize,
// translation state // translation state
sleeping: Vec<Vec<Expression>>, pending: Vec<Vec<Expression>>,
living: Vec<Expression>, stack: Vec<Expression>,
last_stack: usize, last_stack: usize,
} }
@ -41,8 +41,8 @@ impl<'a> Transformer<'a> {
wasm, wasm,
arity, arity,
name, name,
sleeping: Vec::new(), pending: Vec::new(),
living: Vec::new(), stack: Vec::new(),
last_stack: 0, last_stack: 0,
} }
} }
@ -62,11 +62,11 @@ impl<'a> Transformer<'a> {
} }
fn push_recall(&mut self, num: u32) { fn push_recall(&mut self, num: u32) {
let len = self.living.len(); let len = self.stack.len();
(len..len + num as usize) (len..len + num as usize)
.map(Expression::Recall) .map(Expression::Recall)
.for_each(|v| self.living.push(v)); .for_each(|v| self.stack.push(v));
} }
fn push_block_result(&mut self, typ: BlockType) { fn push_block_result(&mut self, typ: BlockType) {
@ -82,10 +82,10 @@ impl<'a> Transformer<'a> {
// Since expressions do not have set ordering rules, this is // Since expressions do not have set ordering rules, this is
// safe and condenses code. // safe and condenses code.
fn gen_leak_pending(&mut self, stat: &mut Vec<Statement>) { fn gen_leak_pending(&mut self, stat: &mut Vec<Statement>) {
self.last_stack = self.last_stack.max(self.living.len()); self.last_stack = self.last_stack.max(self.stack.len());
for (i, v) in self for (i, v) in self
.living .stack
.iter_mut() .iter_mut()
.enumerate() .enumerate()
.filter(|v| !v.1.is_recalling(v.0)) .filter(|v| !v.1.is_recalling(v.0))
@ -103,16 +103,16 @@ impl<'a> Transformer<'a> {
// Pending expressions are put to sleep before entering // Pending expressions are put to sleep before entering
// a control structure so that they are not lost. // a control structure so that they are not lost.
fn save_pending(&mut self) { fn save_pending(&mut self) {
self.sleeping.push(self.living.clone()); self.pending.push(self.stack.clone());
} }
fn load_pending(&mut self) { fn load_pending(&mut self) {
self.living = self.sleeping.pop().unwrap(); self.stack = self.pending.pop().unwrap();
} }
fn gen_return(&mut self, stat: &mut Vec<Statement>) { fn gen_return(&mut self, stat: &mut Vec<Statement>) {
let num = self.arity.in_arity[self.name].num_result as usize; let num = self.arity.in_arity[self.name].num_result as usize;
let list = self.living.split_off(self.living.len() - num); let list = self.stack.split_off(self.stack.len() - num);
self.gen_leak_pending(stat); self.gen_leak_pending(stat);
stat.push(Statement::Return(Return { list })); stat.push(Statement::Return(Return { list }));
@ -122,10 +122,10 @@ impl<'a> Transformer<'a> {
let arity = self.arity.arity_of(func as usize); let arity = self.arity.arity_of(func as usize);
let param_list = self let param_list = self
.living .stack
.split_off(self.living.len() - arity.num_param as usize); .split_off(self.stack.len() - arity.num_param as usize);
let len = u32::try_from(self.living.len()).unwrap(); let len = u32::try_from(self.stack.len()).unwrap();
let result = len..len + arity.num_result; let result = len..len + arity.num_result;
self.push_recall(arity.num_result); self.push_recall(arity.num_result);
@ -141,12 +141,12 @@ impl<'a> Transformer<'a> {
let types = self.wasm.type_section().unwrap().types(); let types = self.wasm.type_section().unwrap().types();
let arity = Arity::from_index(types, typ); let arity = Arity::from_index(types, typ);
let index = self.living.pop().unwrap(); let index = self.stack.pop().unwrap();
let param_list = self let param_list = self
.living .stack
.split_off(self.living.len() - arity.num_param as usize); .split_off(self.stack.len() - arity.num_param as usize);
let len = u32::try_from(self.living.len()).unwrap(); let len = u32::try_from(self.stack.len()).unwrap();
let result = len..len + arity.num_result; let result = len..len + arity.num_result;
self.push_recall(arity.num_result); self.push_recall(arity.num_result);
@ -160,9 +160,9 @@ impl<'a> Transformer<'a> {
} }
fn push_load(&mut self, op: Load, offset: u32) { fn push_load(&mut self, op: Load, offset: u32) {
let pointer = Box::new(self.living.pop().unwrap()); let pointer = Box::new(self.stack.pop().unwrap());
self.living.push(Expression::AnyLoad(AnyLoad { self.stack.push(Expression::AnyLoad(AnyLoad {
op, op,
offset, offset,
pointer, pointer,
@ -170,8 +170,8 @@ impl<'a> Transformer<'a> {
} }
fn gen_store(&mut self, op: Store, offset: u32, stat: &mut Vec<Statement>) { fn gen_store(&mut self, op: Store, offset: u32, stat: &mut Vec<Statement>) {
let value = self.living.pop().unwrap(); let value = self.stack.pop().unwrap();
let pointer = self.living.pop().unwrap(); let pointer = self.stack.pop().unwrap();
self.gen_leak_pending(stat); self.gen_leak_pending(stat);
stat.push(Statement::AnyStore(AnyStore { stat.push(Statement::AnyStore(AnyStore {
@ -183,20 +183,20 @@ impl<'a> Transformer<'a> {
} }
fn push_constant(&mut self, value: Value) { fn push_constant(&mut self, value: Value) {
self.living.push(Expression::Value(value)); self.stack.push(Expression::Value(value));
} }
fn push_un_op(&mut self, op: UnOp) { fn push_un_op(&mut self, op: UnOp) {
let rhs = Box::new(self.living.pop().unwrap()); let rhs = Box::new(self.stack.pop().unwrap());
self.living.push(Expression::AnyUnOp(AnyUnOp { op, rhs })); self.stack.push(Expression::AnyUnOp(AnyUnOp { op, rhs }));
} }
fn push_bin_op(&mut self, op: BinOp) { fn push_bin_op(&mut self, op: BinOp) {
let rhs = Box::new(self.living.pop().unwrap()); let rhs = Box::new(self.stack.pop().unwrap());
let lhs = Box::new(self.living.pop().unwrap()); let lhs = Box::new(self.stack.pop().unwrap());
self.living self.stack
.push(Expression::AnyBinOp(AnyBinOp { op, lhs, rhs })); .push(Expression::AnyBinOp(AnyBinOp { op, lhs, rhs }));
} }
@ -243,7 +243,7 @@ impl<'a> Transformer<'a> {
stat.push(Statement::Backward(data)); stat.push(Statement::Backward(data));
} }
Inst::If(t) => { Inst::If(t) => {
let cond = self.living.pop().unwrap(); let cond = self.stack.pop().unwrap();
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);
@ -258,7 +258,7 @@ impl<'a> Transformer<'a> {
break; break;
} }
Inst::End => { Inst::End => {
if list.is_empty() && !self.living.is_empty() { if list.is_empty() && !self.stack.is_empty() {
self.gen_return(&mut stat); self.gen_return(&mut stat);
} else { } else {
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);
@ -271,13 +271,13 @@ impl<'a> Transformer<'a> {
stat.push(Statement::Br(Br { target: *i })); stat.push(Statement::Br(Br { target: *i }));
} }
Inst::BrIf(i) => { Inst::BrIf(i) => {
let cond = self.living.pop().unwrap(); let cond = self.stack.pop().unwrap();
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);
stat.push(Statement::BrIf(BrIf { cond, target: *i })); stat.push(Statement::BrIf(BrIf { cond, target: *i }));
} }
Inst::BrTable(t) => { Inst::BrTable(t) => {
let cond = self.living.pop().unwrap(); let cond = self.stack.pop().unwrap();
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);
stat.push(Statement::BrTable(BrTable { stat.push(Statement::BrTable(BrTable {
@ -295,20 +295,20 @@ impl<'a> Transformer<'a> {
self.gen_call_indirect(*i, *t, &mut stat); self.gen_call_indirect(*i, *t, &mut stat);
} }
Inst::Drop => { Inst::Drop => {
self.living.pop().unwrap(); self.stack.pop().unwrap();
} }
Inst::Select => { Inst::Select => {
let cond = Box::new(self.living.pop().unwrap()); let cond = Box::new(self.stack.pop().unwrap());
let b = Box::new(self.living.pop().unwrap()); let b = Box::new(self.stack.pop().unwrap());
let a = Box::new(self.living.pop().unwrap()); let a = Box::new(self.stack.pop().unwrap());
self.living.push(Expression::Select(Select { cond, a, b })); self.stack.push(Expression::Select(Select { cond, a, b }));
} }
Inst::GetLocal(i) => { Inst::GetLocal(i) => {
self.living.push(Expression::GetLocal(GetLocal { var: *i })); self.stack.push(Expression::GetLocal(GetLocal { var: *i }));
} }
Inst::SetLocal(i) => { Inst::SetLocal(i) => {
let value = self.living.pop().unwrap(); let value = self.stack.pop().unwrap();
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);
stat.push(Statement::SetLocal(SetLocal { var: *i, value })); stat.push(Statement::SetLocal(SetLocal { var: *i, value }));
@ -316,16 +316,16 @@ impl<'a> Transformer<'a> {
Inst::TeeLocal(i) => { Inst::TeeLocal(i) => {
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);
let value = self.living.last().unwrap().clone(); let value = self.stack.last().unwrap().clone();
stat.push(Statement::SetLocal(SetLocal { var: *i, value })); stat.push(Statement::SetLocal(SetLocal { var: *i, value }));
} }
Inst::GetGlobal(i) => { Inst::GetGlobal(i) => {
self.living self.stack
.push(Expression::GetGlobal(GetGlobal { var: *i })); .push(Expression::GetGlobal(GetGlobal { var: *i }));
} }
Inst::SetGlobal(i) => { Inst::SetGlobal(i) => {
let value = self.living.pop().unwrap(); let value = self.stack.pop().unwrap();
stat.push(Statement::SetGlobal(SetGlobal { var: *i, value })); stat.push(Statement::SetGlobal(SetGlobal { var: *i, value }));
} }
@ -353,14 +353,14 @@ impl<'a> Transformer<'a> {
Inst::I64Store16(_, o) => self.gen_store(Store::I64_N16, *o, &mut stat), Inst::I64Store16(_, o) => self.gen_store(Store::I64_N16, *o, &mut stat),
Inst::I64Store32(_, o) => self.gen_store(Store::I64_N32, *o, &mut stat), Inst::I64Store32(_, o) => self.gen_store(Store::I64_N32, *o, &mut stat),
Inst::CurrentMemory(i) => { Inst::CurrentMemory(i) => {
self.living self.stack
.push(Expression::MemorySize(MemorySize { memory: *i })); .push(Expression::MemorySize(MemorySize { memory: *i }));
} }
Inst::GrowMemory(i) => { Inst::GrowMemory(i) => {
let value = Box::new(self.living.pop().unwrap()); let value = Box::new(self.stack.pop().unwrap());
// `MemoryGrow` is an expression *but* it has side effects // `MemoryGrow` is an expression *but* it has side effects
self.living self.stack
.push(Expression::MemoryGrow(MemoryGrow { memory: *i, value })); .push(Expression::MemoryGrow(MemoryGrow { memory: *i, value }));
self.gen_leak_pending(&mut stat); self.gen_leak_pending(&mut stat);