diff --git a/compiler/src/regify/basic_block.rs b/compiler/src/regify/basic_block.rs new file mode 100644 index 0000000..927d1f0 --- /dev/null +++ b/compiler/src/regify/basic_block.rs @@ -0,0 +1,91 @@ +//! A block is a run of instructions control enters at the top and leaves at the +//! bottom. Blocks are all regify needs: they say what stack a block is entered +//! with, and where two paths meet -- the only thing a linear walk gets wrong. + +use crate::parse::{ImmOperand, Instr, opcodes::OpCode}; + +#[derive(Debug)] +pub struct Block { + /// The blocks control can reach from this one. + pub succ: Vec, + + /// `(slot value, incoming value)` for every path in AFTER the first. The + /// slot keeps the id the first path gave it, so a later path's value has to + /// be joined into it. That is the phi, and it stays data because nothing + /// here has to run it -- infer folds the types together instead. + pub phi: Vec<(usize, usize)>, +} + +pub fn find_basic_blocks(code: &[Instr], pcs: &[usize]) -> (Vec, Vec) { + let mut starts = vec![0]; + + for (at, instr) in code.iter().enumerate() { + if let Some(target) = jump_target(instr.imm_operands, pcs) { + starts.push(target); + } + + if ends_block(instr, pcs) && at + 1 < code.len() { + starts.push(at + 1); + } + } + + starts.sort_unstable(); + starts.dedup(); + + let ends = |i: usize| starts.get(i + 1).copied().unwrap_or(code.len()); + + // A block reaches wherever its last instruction goes: the jump's target, + // and the block below whenever control can run off the end. + let blocks = (0..starts.len()) + .map(|i| { + let last = &code[ends(i) - 1]; + let mut succ = vec![]; + + if let Some(t) = jump_target(last.imm_operands, pcs) { + succ.extend(starts.iter().position(|&s| s == t)); + } + + if falls_through(last.op) && i + 1 < starts.len() { + succ.push(i + 1); + } + + Block { succ, phi: vec![] } + }) + .collect(); + + (starts, blocks) +} + +/// True when a block cannot carry on past this instruction, because it jumps +/// or because it leaves the function. +fn ends_block(instr: &Instr, pcs: &[usize]) -> bool { + !falls_through(instr.op) || jump_target(instr.imm_operands, pcs).is_some() +} + +/// The instruction a jump lands on. A target arrives as a byte offset, so it is +/// looked up in the pcs; one past the end lands nowhere and is dropped. +fn jump_target(imm: ImmOperand, pcs: &[usize]) -> Option { + let target = match imm { + ImmOperand::Label { target } + | ImmOperand::LabelU16 { target, .. } + | ImmOperand::AtomLabelU8 { target, .. } + | ImmOperand::AtomLabelU16 { target, .. } => target, + _ => return None, + }; + + pcs.iter().position(|&pc| pc == target) +} + +/// True when control can leave a block by running off the end of it. +fn falls_through(op: OpCode) -> bool { + !matches!( + op, + OpCode::Goto + | OpCode::Goto8 + | OpCode::Goto16 + | OpCode::Return + | OpCode::ReturnUndef + | OpCode::ReturnAsync + | OpCode::Throw + ) +} diff --git a/compiler/src/regify.rs b/compiler/src/regify/mod.rs similarity index 56% rename from compiler/src/regify.rs rename to compiler/src/regify/mod.rs index c6b04b2..fe62ec1 100644 --- a/compiler/src/regify.rs +++ b/compiler/src/regify/mod.rs @@ -1,10 +1,15 @@ +mod basic_block; + use std::fmt::Debug; use crate::{ flatten::{Capture, FlatFn}, - parse::{ImmOperand, Instr, JsValue, opcodes::OpCode}, + parse::{ImmOperand, JsValue, opcodes::OpCode}, }; +pub use basic_block::Block; +use basic_block::find_basic_blocks; + #[derive(Clone)] pub struct RegInstr { /// True on the first instruction of a basic block. It rides with the @@ -51,45 +56,6 @@ impl Debug for RegInstr { } } -// ─────────────────────────────── Basic Blocks ─────────────────────────────── -// A block is a run of instructions control enters at the top and leaves at the -// bottom. Blocks are all regify needs: they say what stack a block is entered -// with, and where two paths meet -- the only thing a linear walk gets wrong. - -#[derive(Debug)] -pub struct Block { - /// The blocks control can reach from this one. - pub succ: Vec, - - /// The value ids this block's stack slots hold when it is entered. The - /// first path in fixes them. None until one arrives. - entry: Option>, - - /// `(slot value, incoming value)` for every path in AFTER the first. The - /// slot keeps the id the first path gave it, so a later path's value has to - /// be joined into it. That is the phi, and it stays data because nothing - /// here has to run it -- infer folds the types together instead. - pub phi: Vec<(usize, usize)>, -} - -impl Block { - /// Arrive along one edge, with `stack` in hand. The first arrival names the - /// slots; every later one is reconciled against those names. - fn arrive(&mut self, stack: &[usize]) { - match &self.entry { - None => self.entry = Some(stack.to_vec()), - Some(slots) => self - .phi - .extend(slots.iter().copied().zip(stack.iter().copied())), - } - } - - /// The stack this block starts with. Empty when nothing reaches it. - fn entry_stack(&self) -> Vec { - self.entry.clone().unwrap_or_default() - } -} - #[derive(Debug)] pub struct RegFn { pub name: String, @@ -111,22 +77,29 @@ impl RegFn { let mut next_val = flat_fn.var_count; // Reserve values for locals - // Emit per block, so blocks can be WALKED in the order control reaches - // them and still be READ in listing order. Listing order alone is not - // enough: a for-of puts its body before the test, and the body is - // reached only by the back edge, so walking it first finds no stack. - let mut emitted = vec![Vec::new(); blocks.len()]; - let mut seen = vec![false; blocks.len()]; - let mut todo = vec![0]; - seen[0] = true; + // One instruction in, one out, so a block's output lands exactly where + // its input was and blocks can be walked in any order. A block nothing + // reaches keeps its nops, which is what unreachable code should leave. + let mut output = + vec![RegInstr::new(OpCode::Nop, ImmOperand::None, vec![], vec![]); flat_fn.code.len()]; - while let Some(b) = todo.pop() { + // A worklist, because listing order does not reach every block: a + // for-of puts its body BEFORE the test, so the body is entered only by + // the back edge, from a block further down. A block joins the list the + // once, when the first path arrives with a stack for it. The function + // itself is entered at block 0, holding nothing. + let mut entry_stack = vec![None; blocks.len()]; + let mut worklist = vec![]; + + entry_stack[0] = Some(vec![]); + worklist.push(0); + + while let Some(b) = worklist.pop() { // A block starts with the stack it is ENTERED with, not with // whatever the block above it in the listing left behind. This one // line is what stops the walk running off a `return` into a // jump-only path, or through a `goto` into the arm it jumps over. - let mut stack = blocks[b].entry_stack(); - let mut first = true; + let mut stack = entry_stack[b].clone().unwrap_or_default(); let mut fresh_val = || { let v = next_val; @@ -136,7 +109,9 @@ impl RegFn { let end = starts.get(b + 1).copied().unwrap_or(flat_fn.code.len()); - for instr in &flat_fn.code[starts[b]..end] { + for at in starts[b]..end { + let instr = &flat_fn.code[at]; + let mut reg_instr = RegInstr { block_start: false, dsts: vec![], @@ -219,26 +194,33 @@ impl RegFn { } } - reg_instr.block_start = std::mem::take(&mut first); - emitted[b].push(reg_instr); + output[at] = reg_instr; } // Every edge out of here arrives at its target with this stack. - // Walking a block only after something has arrived at it is what - // makes the entry stack right, and it is why the order is the CFG's - // and not the listing's. for i in 0..blocks[b].succ.len() { let to = blocks[b].succ[i]; - blocks[to].arrive(&stack); - if !seen[to] { - seen[to] = true; - todo.push(to); + // A later path is reconciled against the names the first one + // left, and that pairing is the phi. + if let Some(slots) = &entry_stack[to] { + blocks[to] + .phi + .extend(slots.iter().copied().zip(stack.iter().copied())); + } + // The first path names the block's slots, and is the one that + // puts it on the worklist. + else { + entry_stack[to] = Some(stack.clone()); + worklist.push(to); } } } - let output = emitted.into_iter().flatten().collect::>(); + // Every block begins where its first instruction sits, walked or not. + for &start in &starts { + output[start].block_start = true; + } Self { name: flat_fn.name, @@ -266,84 +248,6 @@ impl RegFn { /// jump target, and after anything a block cannot continue past. /// /// Two things come back: where each block starts, which is only good while the -/// code stands still, and the block itself, which outlives every later pass. -fn find_basic_blocks(code: &[Instr], pcs: &[usize]) -> (Vec, Vec) { - let mut starts = vec![0]; - - for (at, instr) in code.iter().enumerate() { - if let Some(target) = jump_target(instr.imm_operands, pcs) { - starts.push(target); - } - - if ends_block(instr, pcs) && at + 1 < code.len() { - starts.push(at + 1); - } - } - - starts.sort_unstable(); - starts.dedup(); - - let ends = |i: usize| starts.get(i + 1).copied().unwrap_or(code.len()); - - // A block reaches wherever its last instruction goes: the jump's target, - // and the block below whenever control can run off the end. - let blocks = (0..starts.len()) - .map(|i| { - let last = &code[ends(i) - 1]; - let mut succ = vec![]; - - if let Some(t) = jump_target(last.imm_operands, pcs) { - succ.extend(starts.iter().position(|&s| s == t)); - } - - if falls_through(last.op) && i + 1 < starts.len() { - succ.push(i + 1); - } - - Block { - succ, - entry: None, - phi: vec![], - } - }) - .collect(); - - (starts, blocks) -} - -/// True when a block cannot carry on past this instruction, because it jumps -/// or because it leaves the function. -fn ends_block(instr: &Instr, pcs: &[usize]) -> bool { - !falls_through(instr.op) || jump_target(instr.imm_operands, pcs).is_some() -} - -/// The instruction a jump lands on. A target arrives as a byte offset, so it is -/// looked up in the pcs; one past the end lands nowhere and is dropped. -fn jump_target(imm: ImmOperand, pcs: &[usize]) -> Option { - let target = match imm { - ImmOperand::Label { target } - | ImmOperand::LabelU16 { target, .. } - | ImmOperand::AtomLabelU8 { target, .. } - | ImmOperand::AtomLabelU16 { target, .. } => target, - _ => return None, - }; - - pcs.iter().position(|&pc| pc == target) -} - -/// True when control can leave a block by running off the end of it. -fn falls_through(op: OpCode) -> bool { - !matches!( - op, - OpCode::Goto - | OpCode::Goto8 - | OpCode::Goto16 - | OpCode::Return - | OpCode::ReturnUndef - | OpCode::ReturnAsync - | OpCode::Throw - ) -} pub fn regify(flat_fns: Vec) -> Vec { flat_fns.into_iter().map(RegFn::from_flat).collect()