1012 lines
32 KiB
Rust
1012 lines
32 KiB
Rust
use fix_builtins::{BUILTINS, BuiltinId};
|
|
use fix_common::StringId;
|
|
use fix_ir::{Attr, BinOpKind, Ir, MaybeThunk, Param, RawIrRef, ThunkId, UnOpKind};
|
|
use hashbrown::HashMap;
|
|
use num_enum::TryFromPrimitive;
|
|
use rnix::TextRange;
|
|
use string_interner::Symbol as _;
|
|
|
|
pub mod disassembler;
|
|
|
|
pub struct InstructionPtr(pub usize);
|
|
|
|
pub trait BytecodeContext {
|
|
fn intern_string(&mut self, s: &str) -> StringId;
|
|
fn register_span(&mut self, range: TextRange) -> u32;
|
|
fn get_code(&self) -> &[u8];
|
|
fn get_code_mut(&mut self) -> &mut Vec<u8>;
|
|
fn add_constant(&mut self, val: Const) -> u32;
|
|
}
|
|
|
|
#[repr(u8)]
|
|
#[derive(Debug, Clone, Copy, TryFromPrimitive)]
|
|
#[allow(clippy::enum_variant_names)]
|
|
pub enum Op {
|
|
PushSmi,
|
|
PushBigInt,
|
|
PushFloat,
|
|
PushString,
|
|
PushNull,
|
|
PushTrue,
|
|
PushFalse,
|
|
|
|
LoadLocal,
|
|
LoadOuter,
|
|
StoreLocal,
|
|
AllocLocals,
|
|
|
|
MakeThunk,
|
|
MakeClosure,
|
|
MakePatternClosure,
|
|
|
|
Call,
|
|
DispatchPrimOp,
|
|
|
|
MakeAttrs,
|
|
MakeEmptyAttrs,
|
|
SelectStatic,
|
|
SelectDynamic,
|
|
HasAttrPathStatic,
|
|
HasAttrPathDynamic,
|
|
HasAttrStatic,
|
|
HasAttrDynamic,
|
|
HasAttrResolve,
|
|
JumpIfSelectSucceeded,
|
|
JumpIfSelectFailed,
|
|
|
|
MakeList,
|
|
MakeEmptyList,
|
|
|
|
OpAdd,
|
|
OpSub,
|
|
OpMul,
|
|
OpDiv,
|
|
OpEq,
|
|
OpNeq,
|
|
OpLt,
|
|
OpGt,
|
|
OpLeq,
|
|
OpGeq,
|
|
OpConcat,
|
|
OpUpdate,
|
|
|
|
OpNeg,
|
|
OpNot,
|
|
|
|
JumpIfFalse,
|
|
JumpIfTrue,
|
|
Jump,
|
|
|
|
CoerceToString,
|
|
|
|
ConcatStrings,
|
|
ResolvePath,
|
|
|
|
Assert,
|
|
|
|
PushWith,
|
|
PopWith,
|
|
LookupWith,
|
|
PrepareWith,
|
|
|
|
LoadBuiltins,
|
|
LoadBuiltin,
|
|
|
|
LoadReplBinding,
|
|
LoadScopedBinding,
|
|
|
|
Return,
|
|
|
|
Illegal,
|
|
}
|
|
|
|
struct ScopeInfo {
|
|
depth: u8,
|
|
thunk_map: HashMap<ThunkId, u32>,
|
|
}
|
|
|
|
struct BytecodeEmitter<'a, Ctx: BytecodeContext> {
|
|
ctx: &'a mut Ctx,
|
|
scope_stack: Vec<ScopeInfo>,
|
|
}
|
|
|
|
#[repr(u8)]
|
|
#[derive(Debug, Clone, Copy, TryFromPrimitive)]
|
|
pub enum OperandType {
|
|
Const,
|
|
BigInt,
|
|
Local,
|
|
BuiltinConst,
|
|
Builtins,
|
|
ReplBinding,
|
|
ScopedImportBinding,
|
|
WithLookup,
|
|
}
|
|
|
|
pub enum Const {
|
|
Smi(i32),
|
|
Float(f64),
|
|
Bool(bool),
|
|
String(StringId),
|
|
Path(StringId),
|
|
PrimOp {
|
|
id: BuiltinId,
|
|
arity: u8,
|
|
dispatch_ip: u32,
|
|
},
|
|
Null,
|
|
}
|
|
|
|
#[repr(u8)]
|
|
#[derive(Debug, Clone, Copy, TryFromPrimitive)]
|
|
pub enum AttrKeyType {
|
|
Static,
|
|
Dynamic,
|
|
}
|
|
|
|
pub enum InlineOperand {
|
|
Const(Const),
|
|
BigInt(i64),
|
|
Local { layer: u8, local: u32 },
|
|
BuiltinConst(StringId),
|
|
Builtins,
|
|
ReplBinding(StringId),
|
|
ScopedImportBinding(StringId),
|
|
WithLookup(StringId),
|
|
}
|
|
|
|
pub fn compile_bytecode(ir: RawIrRef<'_>, ctx: &mut impl BytecodeContext) -> InstructionPtr {
|
|
let ip = ctx.get_code().len();
|
|
let mut emitter = BytecodeEmitter::new(ctx);
|
|
emitter.emit_toplevel(ir);
|
|
InstructionPtr(ip)
|
|
}
|
|
|
|
impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
|
|
fn new(ctx: &'a mut Ctx) -> Self {
|
|
Self {
|
|
ctx,
|
|
scope_stack: Vec::with_capacity(32),
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
fn inline_maybe_thunk(&self, val: &MaybeThunk) -> InlineOperand {
|
|
use MaybeThunk::*;
|
|
match *val {
|
|
Int(x) => {
|
|
if let Ok(x) = x.try_into() {
|
|
InlineOperand::Const(Const::Smi(x))
|
|
} else {
|
|
InlineOperand::BigInt(x)
|
|
}
|
|
}
|
|
Float(x) => InlineOperand::Const(Const::Float(x)),
|
|
Bool(b) => InlineOperand::Const(Const::Bool(b)),
|
|
Null => InlineOperand::Const(Const::Null),
|
|
Str(id) => InlineOperand::Const(Const::String(id)),
|
|
Path(id) => InlineOperand::Const(Const::String(id)),
|
|
Thunk(id) => {
|
|
let (layer, local) = self.resolve_thunk(id);
|
|
InlineOperand::Local { layer, local }
|
|
}
|
|
Arg { layer } => InlineOperand::Local { layer, local: 0 },
|
|
Builtin(id) => {
|
|
let (_, arity) = BUILTINS[id as usize];
|
|
InlineOperand::Const(Const::PrimOp {
|
|
id,
|
|
arity,
|
|
dispatch_ip: id.entry_phase().ip(),
|
|
})
|
|
}
|
|
BuiltinConst(id) => InlineOperand::BuiltinConst(id),
|
|
Builtins => InlineOperand::Builtins,
|
|
ReplBinding(id) => InlineOperand::ReplBinding(id),
|
|
ScopedImportBinding(id) => InlineOperand::ScopedImportBinding(id),
|
|
WithLookup(id) => InlineOperand::WithLookup(id),
|
|
}
|
|
}
|
|
|
|
fn emit_maybe_thunk(&mut self, val: &MaybeThunk) {
|
|
use InlineOperand::*;
|
|
let operand = self.inline_maybe_thunk(val);
|
|
match operand {
|
|
Const(val) => {
|
|
let idx = self.ctx.add_constant(val);
|
|
self.emit_u8(OperandType::Const as u8);
|
|
self.emit_u32(idx);
|
|
}
|
|
BigInt(val) => {
|
|
self.emit_u8(OperandType::BigInt as u8);
|
|
self.emit_i64(val);
|
|
}
|
|
Local { layer, local } => {
|
|
self.emit_u8(OperandType::Local as u8);
|
|
self.emit_u8(layer);
|
|
self.emit_u32(local);
|
|
}
|
|
BuiltinConst(id) => {
|
|
self.emit_u8(OperandType::BuiltinConst as u8);
|
|
self.emit_str_id(id);
|
|
}
|
|
Builtins => {
|
|
self.emit_u8(OperandType::Builtins as u8);
|
|
}
|
|
ReplBinding(id) => {
|
|
self.emit_u8(OperandType::ReplBinding as u8);
|
|
self.emit_str_id(id);
|
|
}
|
|
ScopedImportBinding(id) => {
|
|
self.emit_u8(OperandType::ScopedImportBinding as u8);
|
|
self.emit_str_id(id);
|
|
}
|
|
WithLookup(id) => {
|
|
self.emit_u8(OperandType::WithLookup as u8);
|
|
self.emit_str_id(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_op(&mut self, op: Op) {
|
|
self.ctx.get_code_mut().push(op as u8);
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_bool(&mut self, val: bool) {
|
|
self.emit_u8(u8::from(val));
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_u8(&mut self, val: u8) {
|
|
self.ctx.get_code_mut().push(val);
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_u16(&mut self, val: u16) {
|
|
self.ctx
|
|
.get_code_mut()
|
|
.extend_from_slice(&val.to_le_bytes());
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_u32(&mut self, val: u32) {
|
|
self.ctx
|
|
.get_code_mut()
|
|
.extend_from_slice(&val.to_le_bytes());
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_i32(&mut self, val: i32) {
|
|
self.ctx
|
|
.get_code_mut()
|
|
.extend_from_slice(&val.to_le_bytes());
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_i64(&mut self, val: i64) {
|
|
self.ctx
|
|
.get_code_mut()
|
|
.extend_from_slice(&val.to_le_bytes());
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_f64(&mut self, val: f64) {
|
|
self.ctx
|
|
.get_code_mut()
|
|
.extend_from_slice(&val.to_le_bytes());
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_i32_placeholder(&mut self) -> usize {
|
|
let offset = self.ctx.get_code_mut().len();
|
|
self.ctx.get_code_mut().extend_from_slice(&[0u8; 4]);
|
|
offset
|
|
}
|
|
#[inline]
|
|
fn patch_i32(&mut self, offset: usize, val: i32) {
|
|
self.ctx.get_code_mut()[offset..offset + 4].copy_from_slice(&val.to_le_bytes());
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_jump_placeholder(&mut self) -> usize {
|
|
self.emit_op(Op::Jump);
|
|
self.emit_i32_placeholder()
|
|
}
|
|
|
|
#[inline]
|
|
fn patch_jump_target(&mut self, placeholder_offset: usize) {
|
|
let current_pos = self.ctx.get_code_mut().len();
|
|
let relative_offset = (current_pos as i32) - (placeholder_offset as i32) - 4;
|
|
self.patch_i32(placeholder_offset, relative_offset);
|
|
}
|
|
|
|
#[inline]
|
|
fn emit_str_id(&mut self, id: StringId) {
|
|
self.ctx
|
|
.get_code_mut()
|
|
.extend_from_slice(&(id.0.to_usize() as u32).to_le_bytes());
|
|
}
|
|
|
|
fn current_depth(&self) -> u8 {
|
|
self.scope_stack.last().map_or(0, |s| s.depth)
|
|
}
|
|
|
|
fn resolve_thunk(&self, id: ThunkId) -> (u8, u32) {
|
|
for scope in self.scope_stack.iter().rev() {
|
|
if let Some(&local_idx) = scope.thunk_map.get(&id) {
|
|
let layer = self.current_depth() - scope.depth;
|
|
return (layer, local_idx);
|
|
}
|
|
}
|
|
panic!("ThunkId {:?} not found in any scope", id);
|
|
}
|
|
|
|
fn emit_load(&mut self, layer: u8, local: u32) {
|
|
if layer == 0 {
|
|
self.emit_op(Op::LoadLocal);
|
|
self.emit_u32(local);
|
|
} else {
|
|
self.emit_op(Op::LoadOuter);
|
|
self.emit_u8(layer);
|
|
self.emit_u32(local);
|
|
}
|
|
}
|
|
|
|
fn count_with_thunks(&self, ir: RawIrRef<'_>) -> usize {
|
|
match ir {
|
|
Ir::With { thunks, body, .. } => thunks.len() + self.count_with_thunks(*body),
|
|
Ir::TopLevel { thunks, body } => thunks.len() + self.count_with_thunks(*body),
|
|
Ir::If { cond, consq, alter } => {
|
|
self.count_with_thunks(*cond)
|
|
+ self.count_with_thunks(*consq)
|
|
+ self.count_with_thunks(*alter)
|
|
}
|
|
Ir::BinOp { lhs, rhs, .. } => {
|
|
self.count_with_thunks(*lhs) + self.count_with_thunks(*rhs)
|
|
}
|
|
Ir::UnOp { rhs, .. } => self.count_with_thunks(*rhs),
|
|
Ir::Call { func, .. } => self.count_with_thunks(*func),
|
|
Ir::Assert {
|
|
assertion, expr, ..
|
|
} => self.count_with_thunks(*assertion) + self.count_with_thunks(*expr),
|
|
Ir::Select { expr, .. } => self.count_with_thunks(*expr),
|
|
Ir::HasAttr { lhs, .. } => self.count_with_thunks(*lhs),
|
|
Ir::ConcatStrings { parts, .. } => {
|
|
parts.iter().map(|p| self.count_with_thunks(*p)).sum()
|
|
}
|
|
_ => 0,
|
|
}
|
|
}
|
|
|
|
fn collect_all_thunks<'ir>(
|
|
&self,
|
|
own_thunks: &[(ThunkId, RawIrRef<'ir>)],
|
|
body: RawIrRef<'ir>,
|
|
) -> Vec<(ThunkId, RawIrRef<'ir>)> {
|
|
let mut all = Vec::from(own_thunks);
|
|
self.collect_with_thunks_recursive(body, &mut all);
|
|
let mut i = 0;
|
|
while i < all.len() {
|
|
let thunk_body = all[i].1;
|
|
self.collect_with_thunks_recursive(thunk_body, &mut all);
|
|
i += 1;
|
|
}
|
|
all
|
|
}
|
|
|
|
fn collect_with_thunks_recursive<'ir>(
|
|
&self,
|
|
ir: RawIrRef<'ir>,
|
|
out: &mut Vec<(ThunkId, RawIrRef<'ir>)>,
|
|
) {
|
|
match ir {
|
|
Ir::With { thunks, body, .. } => {
|
|
for &(id, inner) in thunks.iter() {
|
|
out.push((id, inner));
|
|
}
|
|
self.collect_with_thunks_recursive(*body, out);
|
|
}
|
|
Ir::TopLevel { thunks, body } => {
|
|
for &(id, inner) in thunks.iter() {
|
|
out.push((id, inner));
|
|
}
|
|
self.collect_with_thunks_recursive(*body, out);
|
|
}
|
|
Ir::If { cond, consq, alter } => {
|
|
self.collect_with_thunks_recursive(*cond, out);
|
|
self.collect_with_thunks_recursive(*consq, out);
|
|
self.collect_with_thunks_recursive(*alter, out);
|
|
}
|
|
Ir::BinOp { lhs, rhs, .. } => {
|
|
self.collect_with_thunks_recursive(*lhs, out);
|
|
self.collect_with_thunks_recursive(*rhs, out);
|
|
}
|
|
Ir::UnOp { rhs, .. } => self.collect_with_thunks_recursive(*rhs, out),
|
|
Ir::Call { func, .. } => {
|
|
self.collect_with_thunks_recursive(*func, out);
|
|
}
|
|
Ir::Assert {
|
|
assertion, expr, ..
|
|
} => {
|
|
self.collect_with_thunks_recursive(*assertion, out);
|
|
self.collect_with_thunks_recursive(*expr, out);
|
|
}
|
|
Ir::Select { expr, .. } => {
|
|
self.collect_with_thunks_recursive(*expr, out);
|
|
}
|
|
Ir::HasAttr { lhs, .. } => self.collect_with_thunks_recursive(*lhs, out),
|
|
Ir::ConcatStrings { parts, .. } => {
|
|
for p in parts.iter() {
|
|
self.collect_with_thunks_recursive(*p, out);
|
|
}
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
fn push_scope(&mut self, has_arg: bool, thunk_ids: &[ThunkId]) {
|
|
let depth = self.scope_stack.len().try_into().expect("scope too deep!");
|
|
let thunk_base = if has_arg { 1u32 } else { 0u32 };
|
|
let thunk_map = thunk_ids
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(i, &id)| (id, thunk_base + i as u32))
|
|
.collect();
|
|
self.scope_stack.push(ScopeInfo { depth, thunk_map });
|
|
}
|
|
|
|
fn pop_scope(&mut self) {
|
|
self.scope_stack.pop();
|
|
}
|
|
|
|
fn emit_toplevel(&mut self, ir: RawIrRef<'_>) {
|
|
match ir {
|
|
&Ir::TopLevel { body, ref thunks } => {
|
|
let with_thunk_count = self.count_with_thunks(body);
|
|
let total_slots = thunks.len() + with_thunk_count;
|
|
|
|
let all_thunks = self.collect_all_thunks(thunks, body);
|
|
let thunk_ids: Vec<ThunkId> = all_thunks.iter().map(|&(id, _)| id).collect();
|
|
|
|
self.push_scope(false, &thunk_ids);
|
|
|
|
if total_slots > 0 {
|
|
self.emit_op(Op::AllocLocals);
|
|
self.emit_u32(total_slots as u32);
|
|
}
|
|
|
|
self.emit_scope_thunks(thunks);
|
|
self.emit_expr(body);
|
|
self.emit_op(Op::Return);
|
|
|
|
self.pop_scope();
|
|
}
|
|
_ => {
|
|
self.push_scope(false, &[]);
|
|
self.emit_expr(ir);
|
|
self.emit_op(Op::Return);
|
|
self.pop_scope();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn emit_scope_thunks(&mut self, thunks: &[(ThunkId, RawIrRef<'_>)]) {
|
|
for &(id, inner) in thunks {
|
|
let skip_patch = self.emit_jump_placeholder();
|
|
let entry_point = self.ctx.get_code_mut().len() as u32;
|
|
self.emit_expr(inner);
|
|
self.emit_op(Op::Return);
|
|
self.patch_jump_target(skip_patch);
|
|
self.emit_op(Op::MakeThunk);
|
|
self.emit_u32(entry_point);
|
|
let (_, local_idx) = self.resolve_thunk(id);
|
|
self.emit_op(Op::StoreLocal);
|
|
self.emit_u32(local_idx);
|
|
}
|
|
}
|
|
|
|
fn emit_expr(&mut self, ir: RawIrRef<'_>) {
|
|
match ir {
|
|
&Ir::Int(x) => {
|
|
if let Ok(x) = x.try_into() {
|
|
self.emit_op(Op::PushSmi);
|
|
self.emit_i32(x);
|
|
} else {
|
|
self.emit_op(Op::PushBigInt);
|
|
self.emit_i64(x);
|
|
}
|
|
}
|
|
&Ir::Float(x) => {
|
|
self.emit_op(Op::PushFloat);
|
|
self.emit_f64(x);
|
|
}
|
|
&Ir::Bool(true) => self.emit_op(Op::PushTrue),
|
|
&Ir::Bool(false) => self.emit_op(Op::PushFalse),
|
|
Ir::Null => self.emit_op(Op::PushNull),
|
|
&Ir::Str(id) => {
|
|
self.emit_op(Op::PushString);
|
|
self.emit_str_id(id);
|
|
}
|
|
&Ir::Path(p) => {
|
|
self.emit_expr(p);
|
|
self.emit_op(Op::ResolvePath);
|
|
}
|
|
&Ir::If { cond, consq, alter } => {
|
|
self.emit_expr(cond);
|
|
|
|
self.emit_op(Op::JumpIfFalse);
|
|
let else_placeholder = self.emit_i32_placeholder();
|
|
let after_jif = self.ctx.get_code_mut().len();
|
|
|
|
self.emit_expr(consq);
|
|
|
|
self.emit_op(Op::Jump);
|
|
let end_placeholder = self.emit_i32_placeholder();
|
|
let after_jump = self.ctx.get_code_mut().len();
|
|
|
|
let else_offset = (after_jump as i32) - (after_jif as i32);
|
|
self.patch_i32(else_placeholder, else_offset);
|
|
|
|
self.emit_expr(alter);
|
|
|
|
let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
|
|
self.patch_i32(end_placeholder, end_offset);
|
|
}
|
|
&Ir::BinOp { lhs, rhs, kind } => {
|
|
self.emit_binop(lhs, rhs, kind);
|
|
}
|
|
&Ir::UnOp { rhs, kind } => match kind {
|
|
UnOpKind::Neg => {
|
|
self.emit_expr(rhs);
|
|
self.emit_op(Op::OpNeg);
|
|
}
|
|
UnOpKind::Not => {
|
|
self.emit_expr(rhs);
|
|
self.emit_op(Op::OpNot);
|
|
}
|
|
},
|
|
&Ir::Func {
|
|
body,
|
|
ref param,
|
|
ref thunks,
|
|
} => {
|
|
self.emit_func(thunks, param, body);
|
|
}
|
|
Ir::AttrSet { stcs, dyns } => {
|
|
self.emit_attrset(stcs, dyns);
|
|
}
|
|
Ir::List { items } => {
|
|
if items.is_empty() {
|
|
self.emit_op(Op::MakeEmptyList);
|
|
} else {
|
|
self.emit_op(Op::MakeList);
|
|
self.emit_u32(items.len() as u32);
|
|
for &item in items.iter() {
|
|
self.emit_maybe_thunk(item);
|
|
}
|
|
}
|
|
}
|
|
&Ir::Call { func, arg, .. } => {
|
|
self.emit_expr(func);
|
|
self.emit_op(Op::Call);
|
|
self.emit_maybe_thunk(arg);
|
|
}
|
|
&Ir::Arg { layer } => {
|
|
self.emit_load(layer, 0);
|
|
}
|
|
&Ir::TopLevel { body, ref thunks } => {
|
|
self.emit_toplevel_inner(body, thunks);
|
|
}
|
|
&Ir::Select {
|
|
expr,
|
|
ref attrpath,
|
|
default,
|
|
span,
|
|
} => {
|
|
self.emit_select(expr, attrpath, default, span);
|
|
}
|
|
Ir::Builtins => {
|
|
self.emit_op(Op::LoadBuiltins);
|
|
}
|
|
&Ir::Builtin(id) => {
|
|
self.emit_op(Op::LoadBuiltin);
|
|
self.emit_u8(id as u8);
|
|
}
|
|
&Ir::BuiltinConst(id) => {
|
|
self.emit_select(
|
|
&Ir::Builtins,
|
|
&[Attr::Str(id, TextRange::default())],
|
|
None,
|
|
TextRange::default(),
|
|
);
|
|
}
|
|
&Ir::ConcatStrings {
|
|
ref parts,
|
|
force_string,
|
|
} => {
|
|
for &part in parts.iter() {
|
|
self.emit_expr(part);
|
|
self.emit_op(Op::CoerceToString);
|
|
}
|
|
self.emit_op(Op::ConcatStrings);
|
|
self.emit_u16(parts.len() as u16);
|
|
self.emit_bool(force_string);
|
|
}
|
|
&Ir::HasAttr { lhs, ref rhs } => {
|
|
self.emit_has_attr(lhs, rhs);
|
|
}
|
|
Ir::Assert {
|
|
assertion,
|
|
expr,
|
|
assertion_raw,
|
|
span,
|
|
} => {
|
|
let raw_idx = self.ctx.intern_string(assertion_raw);
|
|
let span_id = self.ctx.register_span(*span);
|
|
self.emit_expr(*assertion);
|
|
self.emit_op(Op::Assert);
|
|
self.emit_str_id(raw_idx);
|
|
self.emit_u32(span_id);
|
|
self.emit_expr(*expr);
|
|
}
|
|
&Ir::ReplBinding(name) => {
|
|
self.emit_op(Op::LoadReplBinding);
|
|
self.emit_str_id(name);
|
|
}
|
|
&Ir::ScopedImportBinding(name) => {
|
|
self.emit_op(Op::LoadScopedBinding);
|
|
self.emit_str_id(name);
|
|
}
|
|
&Ir::With {
|
|
namespace,
|
|
body,
|
|
ref thunks,
|
|
} => {
|
|
self.emit_with(namespace, body, thunks);
|
|
}
|
|
&Ir::WithLookup(name) => {
|
|
// TODO: specialize shallow with lookups
|
|
self.emit_op(Op::PrepareWith);
|
|
self.emit_op(Op::LookupWith);
|
|
self.emit_str_id(name);
|
|
}
|
|
&Ir::MaybeThunk(thunk) => {
|
|
use MaybeThunk::*;
|
|
match *thunk {
|
|
Int(x) => {
|
|
if let Ok(x) = x.try_into() {
|
|
self.emit_op(Op::PushSmi);
|
|
self.emit_i32(x);
|
|
} else {
|
|
self.emit_op(Op::PushBigInt);
|
|
self.emit_i64(x);
|
|
}
|
|
}
|
|
Float(x) => {
|
|
self.emit_op(Op::PushFloat);
|
|
self.emit_f64(x);
|
|
}
|
|
Bool(true) => self.emit_op(Op::PushTrue),
|
|
Bool(false) => self.emit_op(Op::PushFalse),
|
|
Null => self.emit_op(Op::PushNull),
|
|
Str(id) => {
|
|
self.emit_op(Op::PushString);
|
|
self.emit_str_id(id);
|
|
}
|
|
Path(id) => {
|
|
self.emit_op(Op::PushString);
|
|
self.emit_str_id(id);
|
|
self.emit_op(Op::ResolvePath);
|
|
}
|
|
Thunk(id) => {
|
|
let (layer, local) = self.resolve_thunk(id);
|
|
self.emit_load(layer, local);
|
|
}
|
|
Arg { layer } => self.emit_load(layer, 0),
|
|
Builtin(id) => {
|
|
self.emit_op(Op::LoadBuiltin);
|
|
self.emit_u8(id as u8);
|
|
}
|
|
BuiltinConst(id) => self.emit_select(
|
|
&Ir::Builtins,
|
|
&[Attr::Str(id, TextRange::default())],
|
|
None,
|
|
TextRange::default(),
|
|
),
|
|
Builtins => self.emit_op(Op::LoadBuiltins),
|
|
ReplBinding(name) => {
|
|
self.emit_op(Op::LoadReplBinding);
|
|
self.emit_str_id(name);
|
|
}
|
|
ScopedImportBinding(name) => {
|
|
self.emit_op(Op::LoadScopedBinding);
|
|
self.emit_str_id(name);
|
|
}
|
|
WithLookup(name) => {
|
|
// TODO: specialize shallow with lookups
|
|
self.emit_op(Op::PrepareWith);
|
|
self.emit_op(Op::LookupWith);
|
|
self.emit_str_id(name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn emit_binop(&mut self, lhs: RawIrRef<'_>, rhs: RawIrRef<'_>, kind: BinOpKind) {
|
|
use BinOpKind::*;
|
|
match kind {
|
|
And => {
|
|
self.emit_expr(lhs);
|
|
self.emit_op(Op::JumpIfFalse);
|
|
let skip_placeholder = self.emit_i32_placeholder();
|
|
let after_jif = self.ctx.get_code_mut().len();
|
|
|
|
self.emit_expr(rhs);
|
|
self.emit_op(Op::Jump);
|
|
let end_placeholder = self.emit_i32_placeholder();
|
|
let after_jump = self.ctx.get_code_mut().len();
|
|
|
|
let false_offset = (after_jump as i32) - (after_jif as i32);
|
|
self.patch_i32(skip_placeholder, false_offset);
|
|
|
|
self.emit_op(Op::PushFalse);
|
|
|
|
let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
|
|
self.patch_i32(end_placeholder, end_offset);
|
|
}
|
|
Or => {
|
|
self.emit_expr(lhs);
|
|
self.emit_op(Op::JumpIfTrue);
|
|
let skip_placeholder = self.emit_i32_placeholder();
|
|
let after_jit = self.ctx.get_code_mut().len();
|
|
|
|
self.emit_expr(rhs);
|
|
self.emit_op(Op::Jump);
|
|
let end_placeholder = self.emit_i32_placeholder();
|
|
let after_jump = self.ctx.get_code_mut().len();
|
|
|
|
let true_offset = (after_jump as i32) - (after_jit as i32);
|
|
self.patch_i32(skip_placeholder, true_offset);
|
|
|
|
self.emit_op(Op::PushTrue);
|
|
|
|
let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
|
|
self.patch_i32(end_placeholder, end_offset);
|
|
}
|
|
Impl => {
|
|
self.emit_expr(lhs);
|
|
self.emit_op(Op::JumpIfFalse);
|
|
let skip_placeholder = self.emit_i32_placeholder();
|
|
let after_jif = self.ctx.get_code_mut().len();
|
|
|
|
self.emit_expr(rhs);
|
|
self.emit_op(Op::Jump);
|
|
let end_placeholder = self.emit_i32_placeholder();
|
|
let after_jump = self.ctx.get_code_mut().len();
|
|
|
|
let true_offset = (after_jump as i32) - (after_jif as i32);
|
|
self.patch_i32(skip_placeholder, true_offset);
|
|
|
|
self.emit_op(Op::PushTrue);
|
|
|
|
let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
|
|
self.patch_i32(end_placeholder, end_offset);
|
|
}
|
|
_ => {
|
|
self.emit_expr(lhs);
|
|
self.emit_expr(rhs);
|
|
self.emit_op(match kind {
|
|
Add => Op::OpAdd,
|
|
Sub => Op::OpSub,
|
|
Mul => Op::OpMul,
|
|
Div => Op::OpDiv,
|
|
Eq => Op::OpEq,
|
|
Neq => Op::OpNeq,
|
|
Lt => Op::OpLt,
|
|
Gt => Op::OpGt,
|
|
Leq => Op::OpLeq,
|
|
Geq => Op::OpGeq,
|
|
Con => Op::OpConcat,
|
|
Upd => Op::OpUpdate,
|
|
_ => unreachable!(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
fn emit_func<'ir>(
|
|
&mut self,
|
|
thunks: &[(ThunkId, RawIrRef<'ir>)],
|
|
param: &Option<Param<'ir>>,
|
|
body: RawIrRef<'ir>,
|
|
) {
|
|
let with_thunk_count = self.count_with_thunks(body);
|
|
let total_slots = thunks.len() + with_thunk_count;
|
|
|
|
let all_thunks = self.collect_all_thunks(thunks, body);
|
|
let thunk_ids: Vec<ThunkId> = all_thunks.iter().map(|&(id, _)| id).collect();
|
|
|
|
let skip_patch = self.emit_jump_placeholder();
|
|
let entry_point = self.ctx.get_code().len() as u32;
|
|
self.push_scope(true, &thunk_ids);
|
|
self.emit_scope_thunks(thunks);
|
|
self.emit_expr(body);
|
|
self.emit_op(Op::Return);
|
|
self.pop_scope();
|
|
self.patch_jump_target(skip_patch);
|
|
|
|
if let Some(Param {
|
|
required,
|
|
optional,
|
|
ellipsis,
|
|
}) = param
|
|
{
|
|
self.emit_op(Op::MakePatternClosure);
|
|
self.emit_u32(entry_point);
|
|
self.emit_u32(total_slots as u32);
|
|
self.emit_u16(required.len() as u16);
|
|
self.emit_u16(optional.len() as u16);
|
|
self.emit_bool(*ellipsis);
|
|
|
|
for &(sym, _) in required.iter() {
|
|
self.emit_str_id(sym);
|
|
}
|
|
for &(sym, _) in optional.iter() {
|
|
self.emit_str_id(sym);
|
|
}
|
|
for &(sym, span) in required.iter().chain(optional.iter()) {
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_str_id(sym);
|
|
self.emit_u32(span_id);
|
|
}
|
|
} else {
|
|
self.emit_op(Op::MakeClosure);
|
|
self.emit_u32(entry_point);
|
|
self.emit_u32(total_slots as u32);
|
|
}
|
|
}
|
|
|
|
fn emit_attrset(
|
|
&mut self,
|
|
stcs: &fix_ir::HashMap<'_, StringId, (&MaybeThunk, TextRange)>,
|
|
dyns: &[(RawIrRef<'_>, &MaybeThunk, TextRange)],
|
|
) {
|
|
if stcs.is_empty() && dyns.is_empty() {
|
|
self.emit_op(Op::MakeEmptyAttrs);
|
|
return;
|
|
}
|
|
|
|
for &(key_expr, _val, _span) in dyns.iter() {
|
|
self.emit_expr(key_expr);
|
|
}
|
|
|
|
self.emit_op(Op::MakeAttrs);
|
|
self.emit_u32(stcs.len() as u32);
|
|
self.emit_u32(dyns.len() as u32);
|
|
|
|
for (&sym, &(val, span)) in stcs.iter() {
|
|
self.emit_str_id(sym);
|
|
self.emit_maybe_thunk(val);
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_u32(span_id);
|
|
}
|
|
|
|
for &(_key, val, span) in dyns.iter() {
|
|
self.emit_maybe_thunk(val);
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_u32(span_id);
|
|
}
|
|
}
|
|
|
|
fn emit_select(
|
|
&mut self,
|
|
expr: RawIrRef<'_>,
|
|
attrpath: &[Attr<RawIrRef<'_>>],
|
|
default: Option<RawIrRef<'_>>,
|
|
span: TextRange,
|
|
) {
|
|
self.emit_expr(expr);
|
|
|
|
let mut dynamic_patches = Vec::new();
|
|
for attr in attrpath.iter() {
|
|
match *attr {
|
|
Attr::Str(sym, _) => {
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_op(Op::SelectStatic);
|
|
self.emit_u32(span_id);
|
|
self.emit_str_id(sym);
|
|
}
|
|
Attr::Dynamic(key_expr, _) => {
|
|
self.emit_op(Op::JumpIfSelectFailed);
|
|
dynamic_patches.push(self.emit_i32_placeholder());
|
|
self.emit_expr(key_expr);
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_op(Op::SelectDynamic);
|
|
self.emit_u32(span_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(default) = default {
|
|
let before: i32 = self.ctx.get_code().len().try_into().unwrap();
|
|
for patch in dynamic_patches {
|
|
self.patch_jump_target(patch);
|
|
}
|
|
self.emit_op(Op::JumpIfSelectSucceeded);
|
|
let placeholder = self.emit_i32_placeholder();
|
|
self.emit_expr(default);
|
|
let after: i32 = self.ctx.get_code().len().try_into().unwrap();
|
|
// Offset is relative to after the placeholder, so subtract the
|
|
// size of JumpIfSelectSucceeded (1) + placeholder (4).
|
|
self.patch_i32(placeholder, after - before - 5);
|
|
} else {
|
|
for patch in dynamic_patches {
|
|
self.patch_jump_target(patch);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn emit_has_attr(&mut self, lhs: RawIrRef<'_>, rhs: &[Attr<RawIrRef<'_>>]) {
|
|
self.emit_expr(lhs);
|
|
|
|
let mut dynamic_patches = Vec::new();
|
|
let [attrs @ .., last] = rhs else {
|
|
panic!("attrpath is empty");
|
|
};
|
|
for attr in attrs {
|
|
match *attr {
|
|
Attr::Str(sym, span) => {
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_op(Op::HasAttrPathStatic);
|
|
self.emit_u32(span_id);
|
|
self.emit_str_id(sym);
|
|
}
|
|
Attr::Dynamic(key_expr, span) => {
|
|
self.emit_op(Op::JumpIfSelectFailed);
|
|
dynamic_patches.push(self.emit_i32_placeholder());
|
|
self.emit_expr(key_expr);
|
|
let span_id = self.ctx.register_span(span);
|
|
self.emit_op(Op::HasAttrPathDynamic);
|
|
self.emit_u32(span_id);
|
|
}
|
|
}
|
|
}
|
|
match *last {
|
|
Attr::Str(sym, _) => {
|
|
self.emit_op(Op::HasAttrStatic);
|
|
self.emit_str_id(sym);
|
|
}
|
|
Attr::Dynamic(key_expr, _) => {
|
|
self.emit_op(Op::JumpIfSelectFailed);
|
|
dynamic_patches.push(self.emit_i32_placeholder());
|
|
self.emit_expr(key_expr);
|
|
self.emit_op(Op::HasAttrDynamic);
|
|
}
|
|
}
|
|
for patch in dynamic_patches {
|
|
self.patch_jump_target(patch);
|
|
}
|
|
self.emit_op(Op::HasAttrResolve);
|
|
}
|
|
|
|
fn emit_with(
|
|
&mut self,
|
|
namespace: &MaybeThunk,
|
|
body: RawIrRef<'_>,
|
|
thunks: &[(ThunkId, RawIrRef<'_>)],
|
|
) {
|
|
self.emit_op(Op::PushWith);
|
|
self.emit_maybe_thunk(namespace);
|
|
self.emit_scope_thunks(thunks);
|
|
self.emit_expr(body);
|
|
self.emit_op(Op::PopWith);
|
|
}
|
|
|
|
fn emit_toplevel_inner(&mut self, body: RawIrRef<'_>, thunks: &[(ThunkId, RawIrRef<'_>)]) {
|
|
self.emit_scope_thunks(thunks);
|
|
self.emit_expr(body);
|
|
}
|
|
}
|