Method next

src/output.rs:341–392

(&mut self)

    type Item = OutputInst<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.insts.is_empty() {
            None
        } else {
            // Any edits happen before the corresponding instruction.
            while let Some((&(pos, edit), rest)) = self.edits.split_first() {
                if pos > self.insts.from {
                    break;
                }
                debug_assert_eq!(pos, self.insts.from);
                self.edits = rest;

                // Skip edits that have been optimized away.
                let Some(edit) = edit else {
                    continue;
                };

                return Some(match edit {
                    Edit::Move { to, from, value } => OutputInst::Move {
                        from,
                        to,
                        value: Some(value),
                    },
                    Edit::EmergencySpill { to, from } => OutputInst::Move {
                        from: Allocation::reg(from),
                        to: Allocation::spillslot(to),
                        value: None,
                    },
                    Edit::EmergencyReload { to, from } => OutputInst::Move {
                        from: Allocation::spillslot(from),
                        to: Allocation::reg(to),
                        value: None,
                    },
                    Edit::Rematerialize { to, value } => OutputInst::Rematerialize { to, value },
                    Edit::IndirectRematerialize { to, value, inputs } => {
                        OutputInst::IndirectRematerialize {
                            to,
                            value,
                            inputs: inputs.as_slice(&self.regalloc.allocations.remat_inputs),
                        }
                    }
                });
            }

            let inst = self.insts.from;
            self.insts.from = self.insts.from.next();
            Some(OutputInst::Inst {
                inst,
                operand_allocs: self.regalloc.allocations.inst_allocations(inst),
            })
        }
    }
}

/// Wrapper around either an original instruction or an inserted move.