Revision control
Copy as Markdown
Other Tools
//! Low-level bytecode emitter, used by ast_builder.
//!
//! This API makes it easy to emit correct individual bytecode instructions.
// Most of this functionality isn't used yet.
#![allow(dead_code)]
use ast::source_atom_set::SourceAtomSetIndex;
use byteorder::{ByteOrder, LittleEndian};
use std::cmp;
use std::collections::HashMap;
use std::convert::TryFrom;
use std::convert::TryInto;
use std::fmt;
use stencil::bytecode_offset::{BytecodeOffset, BytecodeOffsetDiff};
use stencil::frame_slot::FrameSlot;
use stencil::gcthings::{GCThingIndex, GCThingList};
use stencil::opcode::Opcode;
use stencil::regexp::RegExpIndex;
use stencil::scope::ScopeIndex;
use stencil::scope_notes::{ScopeNoteIndex, ScopeNoteList};
use stencil::script::{
ImmutableScriptData, ImmutableScriptDataList, ScriptStencil, ScriptStencilIndex, SourceExtent,
};
// WARNING
// The following section is generated by update_stencil.py.
// Do mot modify manually.
//
// @@@@ BEGIN TYPES @@@@
#[derive(Debug, Clone, Copy)]
pub enum AsyncFunctionResolveKind {
Fulfill = 0,
Reject = 1,
}
#[derive(Debug, Clone, Copy)]
pub enum CheckIsObjectKind {
IteratorNext = 0,
IteratorReturn = 1,
IteratorThrow = 2,
GetIterator = 3,
GetAsyncIterator = 4,
}
#[derive(Debug, Clone, Copy)]
pub enum CompletionKind {
Normal = 0,
Return = 1,
Throw = 2,
}
#[derive(Debug, Clone, Copy)]
pub enum FunctionPrefixKind {
None = 0,
Get = 1,
Set = 2,
}
#[derive(Debug, Clone, Copy)]
pub enum GeneratorResumeKind {
Next = 0,
Throw = 1,
Return = 2,
}
#[derive(Debug, Clone, Copy)]
pub enum ThrowMsgKind {
AssignToCall = 0,
IteratorNoThrow = 1,
CantDeleteSuper = 2,
PrivateDoubleInit = 3,
PrivateBrandDoubleInit = 4,
MissingPrivateOnGet = 5,
MissingPrivateOnSet = 6,
AssignToPrivateMethod = 7,
DecoratorInvalidReturnType = 8,
}
#[derive(Debug, Clone, Copy)]
pub enum ThrowCondition {
ThrowHas = 0,
ThrowHasNot = 1,
OnlyCheckRhs = 2,
}
#[derive(Debug, Clone, Copy)]
pub enum TryNoteKind {
Catch = 0,
Finally = 1,
ForIn = 2,
Destructuring = 3,
ForOf = 4,
ForOfIterClose = 5,
Loop = 6,
}
#[derive(Debug, Clone, Copy)]
pub enum SymbolCode {
IsConcatSpreadable = 0,
Iterator = 1,
Match = 2,
Replace = 3,
Search = 4,
Species = 5,
HasInstance = 6,
Split = 7,
ToPrimitive = 8,
ToStringTag = 9,
Unscopables = 10,
AsyncIterator = 11,
MatchAll = 12,
}
#[derive(Debug, Clone, Copy)]
pub enum SrcNoteType {
Null = 0,
AssignOp = 1,
ColSpan = 2,
NewLine = 3,
SetLine = 4,
Breakpoint = 5,
StepSep = 6,
Unused7 = 7,
XDelta = 8,
}
// @@@@ END TYPES @@@@
#[allow(non_camel_case_types)]
pub type u24 = u32;
/// Low-level bytecode emitter.
pub struct InstructionWriter {
bytecode: Vec<u8>,
/// To de-duplicate atoms in gcthings list, note the index for each atom.
atom_to_gcindex_map: HashMap<SourceAtomSetIndex, GCThingIndex>,
gcthings: GCThingList,
scope_notes: ScopeNoteList,
last_jump_target_offset: Option<BytecodeOffset>,
main_offset: BytecodeOffset,
/// The maximum number of fixed frame slots.
max_fixed_slots: FrameSlot,
/// Stack depth after the instructions emitted so far.
stack_depth: usize,
/// Maximum stack_depth at any point in the instructions emitted so far.
maximum_stack_depth: usize,
body_scope_index: Option<GCThingIndex>,
/// Number of JOF_IC instructions emitted so far.
num_ic_entries: usize,
}
#[derive(Debug)]
pub struct EmitOptions {
pub no_script_rval: bool,
pub extent: SourceExtent,
}
impl EmitOptions {
pub fn new(extent: SourceExtent) -> Self {
Self {
no_script_rval: false,
extent,
}
}
}
/// The error of bytecode-compilation.
#[derive(Clone, Debug)]
pub enum EmitError {
NotImplemented(&'static str),
}
impl fmt::Display for EmitError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
EmitError::NotImplemented(message) => write!(f, "not implemented: {}", message),
}
}
}
impl InstructionWriter {
pub fn new() -> Self {
Self {
bytecode: Vec::new(),
gcthings: GCThingList::new(),
atom_to_gcindex_map: HashMap::new(),
scope_notes: ScopeNoteList::new(),
last_jump_target_offset: None,
main_offset: BytecodeOffset::from(0usize),
max_fixed_slots: FrameSlot::new(0),
stack_depth: 0,
maximum_stack_depth: 0,
body_scope_index: None,
num_ic_entries: 0,
}
}
fn write_i8(&mut self, value: i8) {
self.write_u8(value as u8);
}
fn write_u8(&mut self, value: u8) {
self.bytecode.push(value);
}
fn write_u16(&mut self, value: u16) {
self.bytecode.extend_from_slice(&value.to_le_bytes());
}
fn write_u24(&mut self, value: u24) {
let slice = value.to_le_bytes();
assert!(slice.len() == 4 && slice[3] == 0);
self.bytecode.extend_from_slice(&slice[0..3]);
}
fn write_i32(&mut self, value: i32) {
self.bytecode.extend_from_slice(&value.to_le_bytes());
}
fn write_u32(&mut self, value: u32) {
self.bytecode.extend_from_slice(&value.to_le_bytes());
}
fn write_g_c_thing_index(&mut self, value: GCThingIndex) {
self.write_u32(usize::from(value) as u32);
}
fn write_offset(&mut self, offset: i32) {
self.write_i32(offset);
}
fn write_bytecode_offset_diff(&mut self, offset: BytecodeOffsetDiff) {
self.write_i32(i32::from(offset));
}
fn write_f64(&mut self, val: f64) {
self.bytecode
.extend_from_slice(&val.to_bits().to_le_bytes());
}
fn write_ic_index(&mut self) {
self.write_u32(self.num_ic_entries.try_into().unwrap());
}
fn emit_op(&mut self, opcode: Opcode) {
let nuses: isize = opcode.nuses();
assert!(nuses >= 0);
self.emit_op_common(opcode, nuses as usize);
}
fn emit_argc_op(&mut self, opcode: Opcode, argc: u16) {
assert!(opcode.has_argc());
assert_eq!(opcode.nuses(), -1);
let nuses = match opcode {
Opcode::Call
| Opcode::CallIgnoresRv
| Opcode::Eval
| Opcode::CallIter
| Opcode::StrictEval => {
// callee, this, arguments...
2 + (argc as usize)
}
Opcode::New | Opcode::SuperCall => {
// callee, isConstructing, arguments..., newtarget
2 + (argc as usize) + 1
}
_ => panic!("Unsupported opcode"),
};
self.emit_op_common(opcode, nuses);
}
fn emit_pop_n_op(&mut self, opcode: Opcode, n: u16) {
assert_eq!(opcode.nuses(), -1);
debug_assert_eq!(opcode, Opcode::PopN);
self.emit_op_common(opcode, n as usize);
}
fn emit_op_common(&mut self, opcode: Opcode, nuses: usize) {
assert!(
self.stack_depth >= nuses as usize,
"InstructionWriter misuse! Not enough arguments on the stack."
);
self.stack_depth -= nuses as usize;
let ndefs = opcode.ndefs();
if ndefs > 0 {
self.stack_depth += ndefs;
if self.stack_depth > self.maximum_stack_depth {
self.maximum_stack_depth = self.stack_depth;
}
}
if opcode.has_ic_entry() {
self.num_ic_entries += 1;
}
self.bytecode.push(opcode.to_byte());
}
fn set_last_jump_target_offset(&mut self, target: BytecodeOffset) {
self.last_jump_target_offset = Some(target);
}
fn get_end_of_bytecode(&mut self, offset: BytecodeOffset) -> usize {
// find the offset after the end of bytecode associated with this offset.
let target_opcode = Opcode::try_from(self.bytecode[offset.offset]).unwrap();
offset.offset + target_opcode.instruction_length()
}
pub fn emit_jump_target_and_patch(&mut self, jumplist: &Vec<BytecodeOffset>) {
let mut target = self.bytecode_offset();
let last_jump = self.last_jump_target_offset;
match last_jump {
Some(offset) => {
if self.get_end_of_bytecode(offset) != target.offset {
self.jump_target();
self.set_last_jump_target_offset(target);
} else {
target = offset;
}
}
None => {
self.jump_target();
self.set_last_jump_target_offset(target);
}
}
for jump in jumplist {
self.patch_jump_to_target(target, *jump);
}
}
pub fn patch_jump_to_target(&mut self, target: BytecodeOffset, jump: BytecodeOffset) {
let diff = target.diff_from(jump).into();
let index = jump.offset + 1;
// FIXME: Use native endian instead of little endian
LittleEndian::write_i32(&mut self.bytecode[index..index + 4], diff);
}
pub fn bytecode_offset(&mut self) -> BytecodeOffset {
BytecodeOffset::from(self.bytecode.len())
}
pub fn stack_depth(&self) -> usize {
self.stack_depth
}
pub fn set_stack_depth(&mut self, depth: usize) {
self.stack_depth = depth;
}
// Public methods to emit each instruction.
pub fn emit_boolean(&mut self, value: bool) {
self.emit_op(if value { Opcode::True } else { Opcode::False });
}
pub fn emit_unary_op(&mut self, opcode: Opcode) {
assert!(opcode.is_simple_unary_operator());
self.emit_op(opcode);
}
pub fn emit_binary_op(&mut self, opcode: Opcode) {
assert!(opcode.is_simple_binary_operator());
debug_assert_eq!(opcode.nuses(), 2);
debug_assert_eq!(opcode.ndefs(), 1);
self.emit_op(opcode);
}
pub fn table_switch(
&mut self,
_len: i32,
_low: i32,
_high: i32,
_first_resume_index: u24,
) -> Result<(), EmitError> {
Err(EmitError::NotImplemented("TODO: table_switch"))
}
pub fn numeric(&mut self, value: f64) {
if value.is_finite() && value.fract() == 0.0 {
if i8::min_value() as f64 <= value && value <= i8::max_value() as f64 {
match value as i8 {
0 => self.zero(),
1 => self.one(),
i => self.int8(i),
}
return;
}
if 0.0 <= value {
if value <= u16::max_value() as f64 {
self.uint16(value as u16);
return;
}
if value <= 0x00ffffff as f64 {
self.uint24(value as u24);
return;
}
}
if i32::min_value() as f64 <= value && value <= i32::max_value() as f64 {
self.int32(value as i32);
return;
}
}
self.double_(value);
}
// WARNING
// The following section is generated by update_stencil.py.
// Do mot modify manually.
//
// @@@@ BEGIN METHODS @@@@
pub fn undefined(&mut self) {
self.emit_op(Opcode::Undefined);
}
pub fn null(&mut self) {
self.emit_op(Opcode::Null);
}
pub fn int32(&mut self, val: i32) {
self.emit_op(Opcode::Int32);
self.write_i32(val);
}
pub fn zero(&mut self) {
self.emit_op(Opcode::Zero);
}
pub fn one(&mut self) {
self.emit_op(Opcode::One);
}
pub fn int8(&mut self, val: i8) {
self.emit_op(Opcode::Int8);
self.write_i8(val);
}
pub fn uint16(&mut self, val: u16) {
self.emit_op(Opcode::Uint16);
self.write_u16(val);
}
pub fn uint24(&mut self, val: u24) {
self.emit_op(Opcode::Uint24);
self.write_u24(val);
}
pub fn double_(&mut self, val: f64) {
self.emit_op(Opcode::Double);
self.write_f64(val);
}
pub fn big_int(&mut self, big_int_index: u32) {
self.emit_op(Opcode::BigInt);
self.write_u32(big_int_index);
}
pub fn string(&mut self, atom_index: GCThingIndex) {
self.emit_op(Opcode::String);
self.write_g_c_thing_index(atom_index);
}
pub fn symbol(&mut self, symbol: u8) {
self.emit_op(Opcode::Symbol);
self.write_u8(symbol);
}
pub fn typeof_(&mut self) {
self.emit_op(Opcode::Typeof);
}
pub fn typeof_expr(&mut self) {
self.emit_op(Opcode::TypeofExpr);
}
pub fn inc(&mut self) {
self.emit_op(Opcode::Inc);
}
pub fn dec(&mut self) {
self.emit_op(Opcode::Dec);
}
pub fn to_property_key(&mut self) {
self.emit_op(Opcode::ToPropertyKey);
}
pub fn to_numeric(&mut self) {
self.emit_op(Opcode::ToNumeric);
}
pub fn to_string(&mut self) {
self.emit_op(Opcode::ToString);
}
pub fn is_null_or_undefined(&mut self) {
self.emit_op(Opcode::IsNullOrUndefined);
}
pub fn global_this(&mut self) {
self.emit_op(Opcode::GlobalThis);
}
pub fn non_syntactic_global_this(&mut self) {
self.emit_op(Opcode::NonSyntacticGlobalThis);
}
pub fn new_target(&mut self) {
self.emit_op(Opcode::NewTarget);
}
pub fn dynamic_import(&mut self) {
self.emit_op(Opcode::DynamicImport);
}
pub fn import_meta(&mut self) {
self.emit_op(Opcode::ImportMeta);
}
pub fn new_init(&mut self) {
self.emit_op(Opcode::NewInit);
}
pub fn new_object(&mut self, shape_index: GCThingIndex) {
self.emit_op(Opcode::NewObject);
self.write_g_c_thing_index(shape_index);
}
pub fn object(&mut self, object_index: GCThingIndex) {
self.emit_op(Opcode::Object);
self.write_g_c_thing_index(object_index);
}
pub fn obj_with_proto(&mut self) {
self.emit_op(Opcode::ObjWithProto);
}
pub fn init_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitProp);
self.write_g_c_thing_index(name_index);
}
pub fn init_hidden_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitHiddenProp);
self.write_g_c_thing_index(name_index);
}
pub fn init_locked_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitLockedProp);
self.write_g_c_thing_index(name_index);
}
pub fn init_elem(&mut self) {
self.emit_op(Opcode::InitElem);
}
pub fn init_hidden_elem(&mut self) {
self.emit_op(Opcode::InitHiddenElem);
}
pub fn init_locked_elem(&mut self) {
self.emit_op(Opcode::InitLockedElem);
}
pub fn init_prop_getter(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitPropGetter);
self.write_g_c_thing_index(name_index);
}
pub fn init_hidden_prop_getter(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitHiddenPropGetter);
self.write_g_c_thing_index(name_index);
}
pub fn init_elem_getter(&mut self) {
self.emit_op(Opcode::InitElemGetter);
}
pub fn init_hidden_elem_getter(&mut self) {
self.emit_op(Opcode::InitHiddenElemGetter);
}
pub fn init_prop_setter(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitPropSetter);
self.write_g_c_thing_index(name_index);
}
pub fn init_hidden_prop_setter(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitHiddenPropSetter);
self.write_g_c_thing_index(name_index);
}
pub fn init_elem_setter(&mut self) {
self.emit_op(Opcode::InitElemSetter);
}
pub fn init_hidden_elem_setter(&mut self) {
self.emit_op(Opcode::InitHiddenElemSetter);
}
pub fn get_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetProp);
self.write_g_c_thing_index(name_index);
}
pub fn get_elem(&mut self) {
self.emit_op(Opcode::GetElem);
}
pub fn set_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::SetProp);
self.write_g_c_thing_index(name_index);
}
pub fn strict_set_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::StrictSetProp);
self.write_g_c_thing_index(name_index);
}
pub fn set_elem(&mut self) {
self.emit_op(Opcode::SetElem);
}
pub fn strict_set_elem(&mut self) {
self.emit_op(Opcode::StrictSetElem);
}
pub fn del_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::DelProp);
self.write_g_c_thing_index(name_index);
}
pub fn strict_del_prop(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::StrictDelProp);
self.write_g_c_thing_index(name_index);
}
pub fn del_elem(&mut self) {
self.emit_op(Opcode::DelElem);
}
pub fn strict_del_elem(&mut self) {
self.emit_op(Opcode::StrictDelElem);
}
pub fn has_own(&mut self) {
self.emit_op(Opcode::HasOwn);
}
pub fn check_private_field(&mut self, throw_condition: ThrowCondition, msg_kind: ThrowMsgKind) {
self.emit_op(Opcode::CheckPrivateField);
self.write_u8(throw_condition as u8);
self.write_u8(msg_kind as u8);
}
pub fn new_private_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::NewPrivateName);
self.write_g_c_thing_index(name_index);
}
pub fn super_base(&mut self) {
self.emit_op(Opcode::SuperBase);
}
pub fn get_prop_super(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetPropSuper);
self.write_g_c_thing_index(name_index);
}
pub fn get_elem_super(&mut self) {
self.emit_op(Opcode::GetElemSuper);
}
pub fn set_prop_super(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::SetPropSuper);
self.write_g_c_thing_index(name_index);
}
pub fn strict_set_prop_super(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::StrictSetPropSuper);
self.write_g_c_thing_index(name_index);
}
pub fn set_elem_super(&mut self) {
self.emit_op(Opcode::SetElemSuper);
}
pub fn strict_set_elem_super(&mut self) {
self.emit_op(Opcode::StrictSetElemSuper);
}
pub fn iter(&mut self) {
self.emit_op(Opcode::Iter);
}
pub fn more_iter(&mut self) {
self.emit_op(Opcode::MoreIter);
}
pub fn is_no_iter(&mut self) {
self.emit_op(Opcode::IsNoIter);
}
pub fn end_iter(&mut self) {
self.emit_op(Opcode::EndIter);
}
pub fn close_iter(&mut self, kind: CompletionKind) {
self.emit_op(Opcode::CloseIter);
self.write_u8(kind as u8);
}
pub fn check_is_obj(&mut self, kind: CheckIsObjectKind) {
self.emit_op(Opcode::CheckIsObj);
self.write_u8(kind as u8);
}
pub fn check_obj_coercible(&mut self) {
self.emit_op(Opcode::CheckObjCoercible);
}
pub fn to_async_iter(&mut self) {
self.emit_op(Opcode::ToAsyncIter);
}
pub fn mutate_proto(&mut self) {
self.emit_op(Opcode::MutateProto);
}
pub fn new_array(&mut self, length: u32) {
self.emit_op(Opcode::NewArray);
self.write_u32(length);
}
pub fn init_elem_array(&mut self, index: u32) {
self.emit_op(Opcode::InitElemArray);
self.write_u32(index);
}
pub fn init_elem_inc(&mut self) {
self.emit_op(Opcode::InitElemInc);
}
pub fn hole(&mut self) {
self.emit_op(Opcode::Hole);
}
pub fn reg_exp(&mut self, regexp_index: GCThingIndex) {
self.emit_op(Opcode::RegExp);
self.write_g_c_thing_index(regexp_index);
}
pub fn lambda(&mut self, func_index: GCThingIndex) {
self.emit_op(Opcode::Lambda);
self.write_g_c_thing_index(func_index);
}
pub fn set_fun_name(&mut self, prefix_kind: FunctionPrefixKind) {
self.emit_op(Opcode::SetFunName);
self.write_u8(prefix_kind as u8);
}
pub fn init_home_object(&mut self) {
self.emit_op(Opcode::InitHomeObject);
}
pub fn check_class_heritage(&mut self) {
self.emit_op(Opcode::CheckClassHeritage);
}
pub fn fun_with_proto(&mut self, func_index: GCThingIndex) {
self.emit_op(Opcode::FunWithProto);
self.write_g_c_thing_index(func_index);
}
pub fn builtin_object(&mut self, kind: u8) {
self.emit_op(Opcode::BuiltinObject);
self.write_u8(kind);
}
pub fn call(&mut self, argc: u16) {
self.emit_argc_op(Opcode::Call, argc);
self.write_u16(argc);
}
pub fn call_content(&mut self, argc: u16) {
self.emit_argc_op(Opcode::CallContent, argc);
self.write_u16(argc);
}
pub fn call_iter(&mut self, argc: u16) {
self.emit_argc_op(Opcode::CallIter, argc);
self.write_u16(argc);
}
pub fn call_content_iter(&mut self, argc: u16) {
self.emit_argc_op(Opcode::CallContentIter, argc);
self.write_u16(argc);
}
pub fn call_ignores_rv(&mut self, argc: u16) {
self.emit_argc_op(Opcode::CallIgnoresRv, argc);
self.write_u16(argc);
}
pub fn spread_call(&mut self) {
self.emit_op(Opcode::SpreadCall);
}
pub fn optimize_spread_call(&mut self) {
self.emit_op(Opcode::OptimizeSpreadCall);
}
pub fn eval(&mut self, argc: u16) {
self.emit_argc_op(Opcode::Eval, argc);
self.write_u16(argc);
}
pub fn spread_eval(&mut self) {
self.emit_op(Opcode::SpreadEval);
}
pub fn strict_eval(&mut self, argc: u16) {
self.emit_argc_op(Opcode::StrictEval, argc);
self.write_u16(argc);
}
pub fn strict_spread_eval(&mut self) {
self.emit_op(Opcode::StrictSpreadEval);
}
pub fn implicit_this(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::ImplicitThis);
self.write_g_c_thing_index(name_index);
}
pub fn call_site_obj(&mut self, object_index: GCThingIndex) {
self.emit_op(Opcode::CallSiteObj);
self.write_g_c_thing_index(object_index);
}
pub fn is_constructing(&mut self) {
self.emit_op(Opcode::IsConstructing);
}
pub fn new_(&mut self, argc: u16) {
self.emit_argc_op(Opcode::New, argc);
self.write_u16(argc);
}
pub fn new_content(&mut self, argc: u16) {
self.emit_argc_op(Opcode::NewContent, argc);
self.write_u16(argc);
}
pub fn super_call(&mut self, argc: u16) {
self.emit_argc_op(Opcode::SuperCall, argc);
self.write_u16(argc);
}
pub fn spread_new(&mut self) {
self.emit_op(Opcode::SpreadNew);
}
pub fn spread_super_call(&mut self) {
self.emit_op(Opcode::SpreadSuperCall);
}
pub fn super_fun(&mut self) {
self.emit_op(Opcode::SuperFun);
}
pub fn check_this_reinit(&mut self) {
self.emit_op(Opcode::CheckThisReinit);
}
pub fn generator(&mut self) {
self.emit_op(Opcode::Generator);
}
pub fn initial_yield(&mut self, resume_index: u24) {
self.emit_op(Opcode::InitialYield);
self.write_u24(resume_index);
}
pub fn after_yield(&mut self) {
self.emit_op(Opcode::AfterYield);
self.write_ic_index();
}
pub fn final_yield_rval(&mut self) {
self.emit_op(Opcode::FinalYieldRval);
}
pub fn yield_(&mut self, resume_index: u24) {
self.emit_op(Opcode::Yield);
self.write_u24(resume_index);
}
pub fn is_gen_closing(&mut self) {
self.emit_op(Opcode::IsGenClosing);
}
pub fn async_await(&mut self) {
self.emit_op(Opcode::AsyncAwait);
}
pub fn async_resolve(&mut self, fulfill_or_reject: AsyncFunctionResolveKind) {
self.emit_op(Opcode::AsyncResolve);
self.write_u8(fulfill_or_reject as u8);
}
pub fn await_(&mut self, resume_index: u24) {
self.emit_op(Opcode::Await);
self.write_u24(resume_index);
}
pub fn can_skip_await(&mut self) {
self.emit_op(Opcode::CanSkipAwait);
}
pub fn maybe_extract_await_value(&mut self) {
self.emit_op(Opcode::MaybeExtractAwaitValue);
}
pub fn resume_kind(&mut self, resume_kind: GeneratorResumeKind) {
self.emit_op(Opcode::ResumeKind);
self.write_u8(resume_kind as u8);
}
pub fn check_resume_kind(&mut self) {
self.emit_op(Opcode::CheckResumeKind);
}
pub fn resume(&mut self) {
self.emit_op(Opcode::Resume);
}
pub fn jump_target(&mut self) {
self.emit_op(Opcode::JumpTarget);
self.write_ic_index();
}
pub fn loop_head(&mut self, depth_hint: u8) {
self.emit_op(Opcode::LoopHead);
self.write_ic_index();
self.write_u8(depth_hint);
}
pub fn goto_(&mut self, offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::Goto);
self.write_bytecode_offset_diff(offset);
}
pub fn jump_if_false(&mut self, forward_offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::JumpIfFalse);
self.write_bytecode_offset_diff(forward_offset);
}
pub fn jump_if_true(&mut self, offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::JumpIfTrue);
self.write_bytecode_offset_diff(offset);
}
pub fn and_(&mut self, forward_offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::And);
self.write_bytecode_offset_diff(forward_offset);
}
pub fn or_(&mut self, forward_offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::Or);
self.write_bytecode_offset_diff(forward_offset);
}
pub fn coalesce(&mut self, forward_offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::Coalesce);
self.write_bytecode_offset_diff(forward_offset);
}
pub fn case_(&mut self, forward_offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::Case);
self.write_bytecode_offset_diff(forward_offset);
}
pub fn default_(&mut self, forward_offset: BytecodeOffsetDiff) {
self.emit_op(Opcode::Default);
self.write_bytecode_offset_diff(forward_offset);
}
pub fn return_(&mut self) {
self.emit_op(Opcode::Return);
}
pub fn get_rval(&mut self) {
self.emit_op(Opcode::GetRval);
}
pub fn set_rval(&mut self) {
self.emit_op(Opcode::SetRval);
}
pub fn ret_rval(&mut self) {
self.emit_op(Opcode::RetRval);
}
pub fn check_return(&mut self) {
self.emit_op(Opcode::CheckReturn);
}
pub fn throw_(&mut self) {
self.emit_op(Opcode::Throw);
}
pub fn throw_msg(&mut self, msg_number: ThrowMsgKind) {
self.emit_op(Opcode::ThrowMsg);
self.write_u8(msg_number as u8);
}
pub fn throw_set_const(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::ThrowSetConst);
self.write_g_c_thing_index(name_index);
}
pub fn try_(&mut self) {
self.emit_op(Opcode::Try);
}
pub fn try_destructuring(&mut self) {
self.emit_op(Opcode::TryDestructuring);
}
pub fn exception(&mut self) {
self.emit_op(Opcode::Exception);
}
pub fn finally(&mut self) {
self.emit_op(Opcode::Finally);
}
pub fn uninitialized(&mut self) {
self.emit_op(Opcode::Uninitialized);
}
pub fn init_lexical(&mut self, localno: u24) {
self.emit_op(Opcode::InitLexical);
self.write_u24(localno);
}
pub fn init_g_lexical(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::InitGLexical);
self.write_g_c_thing_index(name_index);
}
pub fn init_aliased_lexical(&mut self, hops: u8, slot: u24) {
self.emit_op(Opcode::InitAliasedLexical);
self.write_u8(hops);
self.write_u24(slot);
}
pub fn check_lexical(&mut self, localno: u24) {
self.emit_op(Opcode::CheckLexical);
self.write_u24(localno);
}
pub fn check_aliased_lexical(&mut self, hops: u8, slot: u24) {
self.emit_op(Opcode::CheckAliasedLexical);
self.write_u8(hops);
self.write_u24(slot);
}
pub fn check_this(&mut self) {
self.emit_op(Opcode::CheckThis);
}
pub fn bind_g_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::BindGName);
self.write_g_c_thing_index(name_index);
}
pub fn bind_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::BindName);
self.write_g_c_thing_index(name_index);
}
pub fn get_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetName);
self.write_g_c_thing_index(name_index);
}
pub fn get_g_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetGName);
self.write_g_c_thing_index(name_index);
}
pub fn get_arg(&mut self, argno: u16) {
self.emit_op(Opcode::GetArg);
self.write_u16(argno);
}
pub fn get_local(&mut self, localno: u24) {
self.emit_op(Opcode::GetLocal);
self.write_u24(localno);
}
pub fn get_aliased_var(&mut self, hops: u8, slot: u24) {
self.emit_op(Opcode::GetAliasedVar);
self.write_u8(hops);
self.write_u24(slot);
}
pub fn get_aliased_debug_var(&mut self, hops: u8, slot: u24) {
self.emit_op(Opcode::GetAliasedDebugVar);
self.write_u8(hops);
self.write_u24(slot);
}
pub fn get_import(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetImport);
self.write_g_c_thing_index(name_index);
}
pub fn get_bound_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetBoundName);
self.write_g_c_thing_index(name_index);
}
pub fn get_intrinsic(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::GetIntrinsic);
self.write_g_c_thing_index(name_index);
}
pub fn callee(&mut self) {
self.emit_op(Opcode::Callee);
}
pub fn env_callee(&mut self, num_hops: u8) {
self.emit_op(Opcode::EnvCallee);
self.write_u8(num_hops);
}
pub fn set_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::SetName);
self.write_g_c_thing_index(name_index);
}
pub fn strict_set_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::StrictSetName);
self.write_g_c_thing_index(name_index);
}
pub fn set_g_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::SetGName);
self.write_g_c_thing_index(name_index);
}
pub fn strict_set_g_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::StrictSetGName);
self.write_g_c_thing_index(name_index);
}
pub fn set_arg(&mut self, argno: u16) {
self.emit_op(Opcode::SetArg);
self.write_u16(argno);
}
pub fn set_local(&mut self, localno: u24) {
self.emit_op(Opcode::SetLocal);
self.write_u24(localno);
}
pub fn set_aliased_var(&mut self, hops: u8, slot: u24) {
self.emit_op(Opcode::SetAliasedVar);
self.write_u8(hops);
self.write_u24(slot);
}
pub fn set_intrinsic(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::SetIntrinsic);
self.write_g_c_thing_index(name_index);
}
pub fn push_lexical_env(&mut self, lexical_scope_index: GCThingIndex) {
self.emit_op(Opcode::PushLexicalEnv);
self.write_g_c_thing_index(lexical_scope_index);
}
pub fn pop_lexical_env(&mut self) {
self.emit_op(Opcode::PopLexicalEnv);
}
pub fn debug_leave_lexical_env(&mut self) {
self.emit_op(Opcode::DebugLeaveLexicalEnv);
}
pub fn recreate_lexical_env(&mut self, lexical_scope_index: GCThingIndex) {
self.emit_op(Opcode::RecreateLexicalEnv);
self.write_g_c_thing_index(lexical_scope_index);
}
pub fn freshen_lexical_env(&mut self, lexical_scope_index: GCThingIndex) {
self.emit_op(Opcode::FreshenLexicalEnv);
self.write_g_c_thing_index(lexical_scope_index);
}
pub fn push_class_body_env(&mut self, lexical_scope_index: GCThingIndex) {
self.emit_op(Opcode::PushClassBodyEnv);
self.write_g_c_thing_index(lexical_scope_index);
}
pub fn push_var_env(&mut self, scope_index: GCThingIndex) {
self.emit_op(Opcode::PushVarEnv);
self.write_g_c_thing_index(scope_index);
}
pub fn enter_with(&mut self, static_with_index: GCThingIndex) {
self.emit_op(Opcode::EnterWith);
self.write_g_c_thing_index(static_with_index);
}
pub fn leave_with(&mut self) {
self.emit_op(Opcode::LeaveWith);
}
pub fn bind_var(&mut self) {
self.emit_op(Opcode::BindVar);
}
pub fn global_or_eval_decl_instantiation(&mut self, last_fun: u32) {
self.emit_op(Opcode::GlobalOrEvalDeclInstantiation);
self.write_u32(last_fun);
}
pub fn del_name(&mut self, name_index: GCThingIndex) {
self.emit_op(Opcode::DelName);
self.write_g_c_thing_index(name_index);
}
pub fn arguments(&mut self) {
self.emit_op(Opcode::Arguments);
}
pub fn rest(&mut self) {
self.emit_op(Opcode::Rest);
}
pub fn function_this(&mut self) {
self.emit_op(Opcode::FunctionThis);
}
pub fn pop(&mut self) {
self.emit_op(Opcode::Pop);
}
pub fn pop_n(&mut self, n: u16) {
self.emit_pop_n_op(Opcode::PopN, n);
self.write_u16(n);
}
pub fn dup(&mut self) {
self.emit_op(Opcode::Dup);
}
pub fn dup2(&mut self) {
self.emit_op(Opcode::Dup2);
}
pub fn dup_at(&mut self, n: u24) {
self.emit_op(Opcode::DupAt);
self.write_u24(n);
}
pub fn swap(&mut self) {
self.emit_op(Opcode::Swap);
}
pub fn pick(&mut self, n: u8) {
self.emit_op(Opcode::Pick);
self.write_u8(n);
}
pub fn unpick(&mut self, n: u8) {
self.emit_op(Opcode::Unpick);
self.write_u8(n);
}
pub fn nop(&mut self) {
self.emit_op(Opcode::Nop);
}
pub fn lineno(&mut self, lineno: u32) {
self.emit_op(Opcode::Lineno);
self.write_u32(lineno);
}
pub fn nop_destructuring(&mut self) {
self.emit_op(Opcode::NopDestructuring);
}
pub fn force_interpreter(&mut self) {
self.emit_op(Opcode::ForceInterpreter);
}
pub fn debug_check_self_hosted(&mut self) {
self.emit_op(Opcode::DebugCheckSelfHosted);
}
pub fn debugger(&mut self) {
self.emit_op(Opcode::Debugger);
}
// @@@@ END METHODS @@@@
pub fn get_atom_gcthing_index(&mut self, atom: SourceAtomSetIndex) -> GCThingIndex {
match self.atom_to_gcindex_map.get(&atom) {
Some(index) => *index,
None => {
let index = self.gcthings.push_atom(atom);
self.atom_to_gcindex_map.insert(atom, index);
index
}
}
}
pub fn get_function_gcthing_index(&mut self, fun_index: ScriptStencilIndex) -> GCThingIndex {
self.gcthings.push_function(fun_index)
}
pub fn get_regexp_gcthing_index(&mut self, regexp_index: RegExpIndex) -> GCThingIndex {
self.gcthings.push_regexp(regexp_index)
}
fn update_max_frame_slots(&mut self, max_frame_slots: FrameSlot) {
self.max_fixed_slots = cmp::max(self.max_fixed_slots, max_frame_slots);
}
pub fn enter_global_scope(&mut self, scope_index: ScopeIndex) {
let index = self.gcthings.push_scope(scope_index);
self.body_scope_index = Some(index);
}
pub fn leave_global_scope(&self) {}
pub fn enter_lexical_scope(
&mut self,
scope_index: ScopeIndex,
parent_scope_note_index: Option<ScopeNoteIndex>,
next_frame_slot: FrameSlot,
needs_environment_object: bool,
) -> ScopeNoteIndex {
self.update_max_frame_slots(next_frame_slot);
let gcthing_index = self.gcthings.push_scope(scope_index);
let offset = self.bytecode_offset();
let note_index =
self.scope_notes
.enter_scope(gcthing_index, offset, parent_scope_note_index);
if needs_environment_object {
self.push_lexical_env(gcthing_index);
}
note_index
}
pub fn leave_lexical_scope(&mut self, index: ScopeNoteIndex, needs_environment_object: bool) {
self.emit_leave_lexical_scope(needs_environment_object);
let offset = self.bytecode_offset();
self.scope_notes.leave_scope(index, offset);
}
fn emit_leave_lexical_scope(&mut self, needs_environment_object: bool) {
if needs_environment_object {
self.pop_lexical_env();
} else {
self.debug_leave_lexical_env();
}
}
pub fn enter_scope_hole_from_lexical(
&mut self,
maybe_hole_scope_note_index: &Option<ScopeNoteIndex>,
parent_scope_note_index: Option<ScopeNoteIndex>,
needs_environment_object: bool,
) -> ScopeNoteIndex {
self.emit_leave_lexical_scope(needs_environment_object);
self.enter_scope_hole(maybe_hole_scope_note_index, parent_scope_note_index)
}
fn enter_scope_hole(
&mut self,
maybe_hole_scope_note_index: &Option<ScopeNoteIndex>,
parent_scope_note_index: Option<ScopeNoteIndex>,
) -> ScopeNoteIndex {
let offset = self.bytecode_offset();
let gcthing_index = match maybe_hole_scope_note_index {
Some(index) => self.scope_notes.get_scope_hole_gcthing_index(index),
None => self
.body_scope_index
.expect("we should have a body scope index"),
};
self.scope_notes
.enter_scope(gcthing_index, offset, parent_scope_note_index)
}
pub fn leave_scope_hole(&mut self, index: ScopeNoteIndex) {
let offset = self.bytecode_offset();
self.scope_notes.leave_scope(index, offset);
}
pub fn switch_to_main(&mut self) {
self.main_offset = self.bytecode_offset();
}
pub fn into_stencil(
self,
script_data_list: &mut ImmutableScriptDataList,
extent: SourceExtent,
) -> Result<ScriptStencil, EmitError> {
let main_offset: usize = self.main_offset.into();
let nfixed: u32 = self.max_fixed_slots.into();
let nslots = nfixed as usize + self.maximum_stack_depth;
let immutable_script_data = script_data_list.push(ImmutableScriptData {
main_offset: main_offset
.try_into()
.map_err(|_| EmitError::NotImplemented("Throwing allocation overflow"))?,
nfixed: self.max_fixed_slots,
nslots: nslots
.try_into()
.map_err(|_| EmitError::NotImplemented("Throwing JSMSG_NEED_DIET"))?,
body_scope_index: usize::from(self.body_scope_index.expect("body scope should be set"))
.try_into()
.map_err(|_| EmitError::NotImplemented("Throwing allocation overflow"))?,
num_ic_entries: self.num_ic_entries.try_into().unwrap(),
fun_length: 0,
bytecode: self.bytecode,
scope_notes: self.scope_notes.into(),
});
Ok(ScriptStencil::top_level_script(
self.gcthings.into(),
immutable_script_data,
extent,
))
}
}