302 lines
10 KiB
Rust
302 lines
10 KiB
Rust
//! Step 1 of declass: rewrite how a class is built, in prototype form.
|
|
//!
|
|
//! A class-build cluster (declass_algo.txt, step 1):
|
|
//!
|
|
//! push_const8 #ctor ; define_class @Name
|
|
//! ( fclosure8 #m ; define_method @meth )*
|
|
//! ( fclosure8 #fields ; set_home_object ; put_loc ; drop )?
|
|
//!
|
|
//! becomes `fclosure8 #ctor` followed, per method, by
|
|
//! `get_field "prototype" ; put_field @meth`; the field-initialiser tail is
|
|
//! dropped. Detection (`find_class_seqs`) records the ranges; replacement
|
|
//! (`ClassSequence::emit_prototype`) reads operands out of each matched range.
|
|
//!
|
|
//! Derived classes (`extends`) are unsupported and panic: prototype form would
|
|
//! have to flatten the parent's prototype in and lower `super`.
|
|
|
|
use std::range::Range;
|
|
|
|
use crate::{
|
|
parse::{AtomRef, ImmOperand, JsValue, atom_names::PREDEFINED_ATOMS, opcodes::OpCode},
|
|
regify::{RegFn, RegInstr},
|
|
};
|
|
|
|
use super::FieldInit;
|
|
|
|
/// Read each constructor <-> field-initialiser link off the class builds, as
|
|
/// fn ids. Run before `rewrite`, which drops the instructions carrying them.
|
|
pub(super) fn field_init_links(fns: &[RegFn]) -> Vec<FieldInit> {
|
|
let mut links = vec![];
|
|
for f in fns {
|
|
for seq in find_class_seqs(&f.code) {
|
|
if let Some(link) = seq.field_init(&f.code, &f.cpool) {
|
|
links.push(link);
|
|
}
|
|
}
|
|
}
|
|
links
|
|
}
|
|
|
|
/// Rewrite every class build in one function to prototype form.
|
|
pub(super) fn rewrite(mut reg_fn: RegFn) -> RegFn {
|
|
let seqs = find_class_seqs(®_fn.code);
|
|
// Move the code out of reg_fn so we can consume it while still calling
|
|
// reg_fn.fresh_val(); the empty Vec left behind costs nothing.
|
|
let code = std::mem::take(&mut reg_fn.code);
|
|
let total = code.len();
|
|
|
|
let mut out = Vec::with_capacity(total);
|
|
let mut instrs = code.into_iter();
|
|
let mut seqs = seqs.iter();
|
|
let mut next_seq = seqs.next();
|
|
let mut pos = 0;
|
|
|
|
while pos < total {
|
|
match next_seq {
|
|
Some(seq) if seq.range.start == pos => {
|
|
let adv = seq.range.end - seq.range.start;
|
|
let matched: Vec<RegInstr> = instrs.by_ref().take(adv).collect();
|
|
seq.emit_prototype(&mut reg_fn, &mut out, &matched);
|
|
pos += adv;
|
|
next_seq = seqs.next();
|
|
}
|
|
_ => {
|
|
out.push(instrs.next().unwrap());
|
|
pos += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
reg_fn.code = out;
|
|
reg_fn
|
|
}
|
|
|
|
struct ClassSequence {
|
|
range: Range<usize>,
|
|
num_methods: usize,
|
|
}
|
|
|
|
impl ClassSequence {
|
|
/// Emit the prototype form, reading operands straight out of `matched` --
|
|
/// the class sequence's own instructions.
|
|
fn emit_prototype(&self, reg_fn: &mut RegFn, out: &mut Vec<RegInstr>, matched: &[RegInstr]) {
|
|
// push_const8 #ctor ; define_class -> fclosure8 #ctor (constructor kept)
|
|
let (ctor_const, ctor_val) = self.ctor(matched);
|
|
out.push(fclosure8(ctor_const, ctor_val));
|
|
|
|
// each ( fclosure8 #m ; define_method @meth ) -> get_field + put_field
|
|
for k in 0..self.num_methods {
|
|
let (method_const, method_val, meth) = self.method(matched, k);
|
|
out.push(fclosure8(method_const, method_val));
|
|
let proto = reg_fn.fresh_val();
|
|
out.push(get_field(proto_atom(), proto, ctor_val));
|
|
out.push(put_field(ImmOperand::Atom(meth), method_val, proto));
|
|
}
|
|
// the fclosure8 #fields ; set_home_object ; put_loc ; drop tail is dropped.
|
|
}
|
|
|
|
/// The constructor's constant and value: push_const8 #ctor ; define_class.
|
|
fn ctor(&self, matched: &[RegInstr]) -> (u32, usize) {
|
|
(as_const(matched[0].imm), matched[1].dsts[0])
|
|
}
|
|
|
|
/// The k-th method's constant, closure value, and name; each method pair
|
|
/// sits after the two constructor instructions.
|
|
fn method(&self, matched: &[RegInstr], k: usize) -> (u32, usize, AtomRef) {
|
|
let fclosure = &matched[2 + 2 * k];
|
|
let define_method = &matched[3 + 2 * k];
|
|
(
|
|
as_const(fclosure.imm),
|
|
fclosure.dsts[0],
|
|
atom_of(define_method.imm),
|
|
)
|
|
}
|
|
|
|
/// The constructor and field-initialiser fn ids, if the class has a
|
|
/// field-initialiser tail. `code` is the whole enclosing function, so the
|
|
/// range indexes it directly.
|
|
fn field_init(&self, code: &[RegInstr], cpool: &[JsValue]) -> Option<FieldInit> {
|
|
let base = 2 + 2 * self.num_methods; // constructor + methods, before the tail
|
|
if self.range.end - self.range.start == base {
|
|
return None; // no field-initialiser tail
|
|
}
|
|
let ctor_const = as_const(code[self.range.start].imm);
|
|
let fields_const = as_const(code[self.range.start + base].imm);
|
|
Some(FieldInit {
|
|
ctor: fn_id(cpool, ctor_const),
|
|
fields: fn_id(cpool, fields_const),
|
|
})
|
|
}
|
|
}
|
|
|
|
fn find_class_seqs(mut ins: &[RegInstr]) -> Vec<ClassSequence> {
|
|
let mut seqs = vec![];
|
|
let mut offset = 0;
|
|
|
|
while !ins.is_empty() {
|
|
match match_class_seq(ins) {
|
|
Ok((rest, num_methods)) => {
|
|
let adv = ins.len() - rest.len();
|
|
|
|
seqs.push(ClassSequence {
|
|
range: Range {
|
|
start: offset,
|
|
end: offset + adv,
|
|
},
|
|
num_methods,
|
|
});
|
|
|
|
offset += adv;
|
|
ins = rest;
|
|
}
|
|
Err(_) => {
|
|
offset += 1;
|
|
ins = &ins[1..];
|
|
}
|
|
}
|
|
}
|
|
|
|
seqs
|
|
}
|
|
|
|
// ── the grammar, as matchers over the instruction stream ───────────────────
|
|
|
|
fn match_class_seq(ins: &[RegInstr]) -> Result<(&[RegInstr], usize), &[RegInstr]> {
|
|
let ins = match_one(ins, |i| i.op == OpCode::PushConst8)?;
|
|
|
|
// A class build is `push_const8 ; define_class`. Derived classes (`extends`)
|
|
// are unsupported: prototype form would have to flatten the parent's
|
|
// prototype in and lower `super`, neither of which is implemented.
|
|
if let Some(i) = ins.first() {
|
|
if i.op == OpCode::DefineClass && is_derived(i) {
|
|
panic!("declass: derived classes (extends) are not supported");
|
|
}
|
|
}
|
|
|
|
let ins = match_one(ins, |i| i.op == OpCode::DefineClass)?;
|
|
let (ins, num_methods) = match_many(ins, match_method_seq);
|
|
let ins = match_opt(ins, match_field_init_seq);
|
|
|
|
Ok((ins, num_methods))
|
|
}
|
|
|
|
/// A derived class: `define_class` with the derived flag set.
|
|
fn is_derived(i: &RegInstr) -> bool {
|
|
matches!(i.imm, ImmOperand::AtomU8 { arg, .. } if arg & 1 == 1)
|
|
}
|
|
|
|
// TODO: accessors are not handled. A getter/setter is a `define_method` with a
|
|
// non-zero kind in `arg`; this matcher takes it for an ordinary method, so it
|
|
// is wrongly lowered to a `put_field` (a data property) instead of an accessor
|
|
// property. It should instead make the whole class pass through untouched.
|
|
fn match_method_seq(ins: &[RegInstr]) -> Result<&[RegInstr], &[RegInstr]> {
|
|
let ins = match_one(ins, |i| i.op == OpCode::Fclosure8)?;
|
|
let ins = match_one(ins, |i| i.op == OpCode::DefineMethod)?;
|
|
Ok(ins)
|
|
}
|
|
|
|
fn match_field_init_seq(ins: &[RegInstr]) -> Result<&[RegInstr], &[RegInstr]> {
|
|
let is_put_loc = |op| {
|
|
matches!(
|
|
op,
|
|
OpCode::PutLoc
|
|
| OpCode::PutLoc8
|
|
| OpCode::PutLoc0
|
|
| OpCode::PutLoc1
|
|
| OpCode::PutLoc2
|
|
| OpCode::PutLoc3
|
|
)
|
|
};
|
|
|
|
let ins = match_one(ins, |i| i.op == OpCode::Fclosure8)?;
|
|
let ins = match_one(ins, |i| i.op == OpCode::SetHomeObject)?;
|
|
let ins = match_one(ins, |i| is_put_loc(i.op))?;
|
|
let ins = match_one(ins, |i| i.op == OpCode::Drop)?;
|
|
Ok(ins)
|
|
}
|
|
|
|
// ── matcher primitives ─────────────────────────────────────────────────────
|
|
|
|
fn match_one(i: &[RegInstr], f: impl Fn(&RegInstr) -> bool) -> Result<&[RegInstr], &[RegInstr]> {
|
|
match i.first() {
|
|
Some(instr) if f(instr) => Ok(&i[1..]),
|
|
_ => Err(i),
|
|
}
|
|
}
|
|
|
|
fn match_many(
|
|
mut i: &[RegInstr],
|
|
f: impl Fn(&[RegInstr]) -> Result<&[RegInstr], &[RegInstr]>,
|
|
) -> (&[RegInstr], usize) {
|
|
let mut n = 0;
|
|
|
|
while let Ok(rest) = f(i) {
|
|
n += 1;
|
|
i = rest;
|
|
}
|
|
|
|
(i, n)
|
|
}
|
|
|
|
fn match_opt<'a>(
|
|
i: &'a [RegInstr],
|
|
f: impl Fn(&'a [RegInstr]) -> Result<&'a [RegInstr], &'a [RegInstr]>,
|
|
) -> &'a [RegInstr] {
|
|
match f(i) {
|
|
Ok(rest) => rest,
|
|
Err(_) => i,
|
|
}
|
|
}
|
|
|
|
// ── emitted instructions ───────────────────────────────────────────────────
|
|
|
|
fn fclosure8(const_index: u32, dst: usize) -> RegInstr {
|
|
RegInstr::new(
|
|
OpCode::Fclosure8,
|
|
ImmOperand::Const(const_index),
|
|
vec![dst],
|
|
vec![],
|
|
)
|
|
}
|
|
|
|
fn get_field(field: ImmOperand, dst: usize, obj: usize) -> RegInstr {
|
|
RegInstr::new(OpCode::GetField, field, vec![dst], vec![obj])
|
|
}
|
|
|
|
fn put_field(field: ImmOperand, value: usize, obj: usize) -> RegInstr {
|
|
RegInstr::new(OpCode::PutField, field, vec![], vec![value, obj])
|
|
}
|
|
|
|
// ── operand helpers ────────────────────────────────────────────────────────
|
|
|
|
fn atom_of(imm: ImmOperand) -> AtomRef {
|
|
match imm {
|
|
ImmOperand::AtomU8 { atom, .. } => atom,
|
|
_ => unreachable!("expected an atom operand"),
|
|
}
|
|
}
|
|
|
|
fn as_const(imm: ImmOperand) -> u32 {
|
|
match imm {
|
|
ImmOperand::Const(c) => c,
|
|
_ => unreachable!("expected a constant operand"),
|
|
}
|
|
}
|
|
|
|
/// The function id a constant-pool entry points at.
|
|
fn fn_id(cpool: &[JsValue], const_index: u32) -> usize {
|
|
match cpool[const_index as usize] {
|
|
JsValue::FnById(id) => id,
|
|
_ => unreachable!("class constant is not a function"),
|
|
}
|
|
}
|
|
|
|
/// The `"prototype"` field name as a predefined-atom operand.
|
|
fn proto_atom() -> ImmOperand {
|
|
let i = PREDEFINED_ATOMS
|
|
.iter()
|
|
.position(|&n| n == "prototype")
|
|
.unwrap();
|
|
ImmOperand::Atom(AtomRef::Predefined(i as u32))
|
|
}
|