refactor(compiler): 原子切换 emit 产出符号化 IR

crates/oxide_compiler/src/class/emit.rs

@@ -1,5 +1,7 @@
 use crate::compiler::{CompileCtx, Compiler, FunctionBodyContext};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{Class, ClassElement, MethodDefinitionKind, PropertyKey};
 
 impl Compiler {
@@ -57,6 +59,17 @@ impl Compiler {
         ctx.in_derived_constructor = is_derived;
         ctx.scopes.private_name_map = private_names.clone();
 
+        let emit_instance_fields = |compiler: &Compiler, field_ctx: &mut CompileCtx| -> Result<(), String> {
+            for field in &instance_fields {
+                if let PropertyKey::PrivateIdentifier(private) = &field.key {
+                    compiler.emit_private_field_init(Operand::This, private.name.as_str(), field.value.as_ref(), field_ctx)?;
+                } else {
+                    compiler.emit_public_field_init(Operand::This, &field.key, field.computed, field.value.as_ref(), field_ctx)?;
+                }
+            }
+            Ok(())
+        };
+
         let mut ctor_module = if let Some(method) = constructor_method {
             let (param_names, body_stmts) = self.extract_function_parts(method.value.as_ref())?;
             self.compile_function_body_with_field_hooks(
@@ -66,27 +79,7 @@ impl Compiler {
                 false,
                 &self_binding,
                 FunctionBodyContext::ClassElement,
-                Some(|compiler: &Compiler, field_ctx: &mut CompileCtx| -> Result<(), String> {
-                    for field in &instance_fields {
-                        if let PropertyKey::PrivateIdentifier(private) = &field.key {
-                            compiler.emit_private_field_init(
-                                254,
-                                private.name.as_str(),
-                                field.value.as_ref(),
-                                field_ctx,
-                            )?;
-                        } else {
-                            compiler.emit_public_field_init(
-                                254,
-                                &field.key,
-                                field.computed,
-                                field.value.as_ref(),
-                                field_ctx,
-                            )?;
-                        }
-                    }
-                    Ok(())
-                }),
+                Some(&emit_instance_fields),
                 is_derived,
             )?
         } else {
@@ -97,54 +90,21 @@ impl Compiler {
                 false,
                 &self_binding,
                 FunctionBodyContext::ClassElement,
-                Some(|compiler: &Compiler, field_ctx: &mut CompileCtx| -> Result<(), String> {
-                    for field in &instance_fields {
-                        if let PropertyKey::PrivateIdentifier(private) = &field.key {
-                            compiler.emit_private_field_init(
-                                254,
-                                private.name.as_str(),
-                                field.value.as_ref(),
-                                field_ctx,
-                            )?;
-                        } else {
-                            compiler.emit_public_field_init(
-                                254,
-                                &field.key,
-                                field.computed,
-                                field.value.as_ref(),
-                                field_ctx,
-                            )?;
-                        }
-                    }
-                    Ok(())
-                }),
+                Some(&emit_instance_fields),
                 is_derived,
             )?;
             if is_derived {
-                module.bytecode.clear();
+                module.insts.clear();
                 module.constants.clear();
                 module.n_registers = 1;
-                module.bytecode.push(opcode::encode(OpCode::SUPER_CALL, 0, 0, 0));
-                module.bytecode.push(0);
+                module.insts.push(Inst::super_call(Operand::None, Operand::None, 0));
                 let mut field_ctx = CompileCtx::new();
                 field_ctx.scopes.private_name_map = private_names.clone();
-                for field in &instance_fields {
-                    if let PropertyKey::PrivateIdentifier(private) = &field.key {
-                        self.emit_private_field_init(254, private.name.as_str(), field.value.as_ref(), &mut field_ctx)?;
-                    } else {
-                        self.emit_public_field_init(
-                            254,
-                            &field.key,
-                            field.computed,
-                            field.value.as_ref(),
-                            &mut field_ctx,
-                        )?;
-                    }
-                }
-                module.bytecode.extend(field_ctx.bytecode);
+                emit_instance_fields(self, &mut field_ctx)?;
+                module.insts.extend(field_ctx.insts);
                 module.constants = field_ctx.constants;
                 module.n_registers = field_ctx.max_regs.max(1);
-                module.bytecode.push(opcode::encode(OpCode::RETURN, 0, 0, 0));
+                module.insts.push(Inst::new(OpCode::RETURN, Operand::None, Operand::None, Operand::None));
             }
             module
         };
@@ -152,9 +112,9 @@ impl Compiler {
         ctor_module.is_class_constructor = true;
         ctor_module.is_derived_constructor = is_derived;
         ctor_module.function_name = ctor_name.clone();
-        ctx.sub_modules.push(ctor_module);
+        ctx.nested.push(ctor_module);
 
-        self.emit_class_prototype(ctor_reg, proto_reg, super_reg, ctx.sub_modules.len() as u32, ctx)?;
+        self.emit_class_prototype(ctor_reg, proto_reg, super_reg, ctx.nested.len() as u16, ctx)?;
         self.emit_class_methods(&class.body.body, ctor_reg, proto_reg, &self_binding, ctx)?;
         self.emit_class_static_elements(&class.body.body, ctor_reg, ctx)?;
 

crates/oxide_compiler/src/class/field.rs

@@ -1,4 +1,5 @@
 use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::operand::Operand;
 use oxide_parser::{ClassElement, PropertyKey};
 
 impl Compiler {
@@ -17,9 +18,9 @@ impl Compiler {
                     let prop = prop.as_ref();
                     if prop.r#static {
                         if let PropertyKey::PrivateIdentifier(private) = &prop.key {
-                            self.emit_private_field_init(ctor_reg, private.name.as_str(), prop.value.as_ref(), ctx)?;
+                            self.emit_private_field_init(Operand::Reg(ctor_reg as u32), private.name.as_str(), prop.value.as_ref(), ctx)?;
                         } else {
-                            self.emit_public_field_init(ctor_reg, &prop.key, prop.computed, prop.value.as_ref(), ctx)?;
+                            self.emit_public_field_init(Operand::Reg(ctor_reg as u32), &prop.key, prop.computed, prop.value.as_ref(), ctx)?;
                         }
                     }
                 }

crates/oxide_compiler/src/class/method.rs

@@ -1,6 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler, FunctionBodyContext};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{ClassElement, MethodDefinitionKind, PropertyKey};
 
 impl Compiler {
@@ -17,7 +19,7 @@ impl Compiler {
                     }
                     if matches!(method.key, PropertyKey::PrivateIdentifier(_)) {
                         let home_reg = if method.r#static { ctor_reg } else { proto_reg };
-                        self.emit_private_method_init(home_reg, method, home_reg, ctx)?;
+                        self.emit_private_method_init(Operand::Reg(home_reg as u32), method, Operand::Reg(home_reg as u32), ctx)?;
                         continue;
                     }
                     let home_reg = if method.r#static { ctor_reg } else { proto_reg };
@@ -28,13 +30,13 @@ impl Compiler {
                         self.class_property_name(&method.key)?
                     };
                     let accessor_reg =
-                        self.emit_class_method_function(method, &method_name, home_reg, ctx, self_binding)?;
+                        self.emit_class_method_function(method, &method_name, Operand::Reg(home_reg as u32), ctx, self_binding)?;
                     match method.kind {
                         MethodDefinitionKind::Method => {
                             if method.computed {
-                                ctx.emit(opcode::encode(OpCode::SET_PROP_DYNAMIC, home_reg, key_reg, accessor_reg));
+                                ctx.inst(Inst::new(OpCode::SET_PROP_DYNAMIC, Operand::Reg(home_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(accessor_reg as u32)));
                             } else {
-                                ctx.emit(opcode::encode(OpCode::SET_PROP, home_reg, accessor_reg, key_reg));
+                                ctx.inst(Inst::new(OpCode::SET_PROP, Operand::Reg(home_reg as u32), Operand::Reg(accessor_reg as u32), Operand::Reg(key_reg as u32)));
                             }
                         }
                         MethodDefinitionKind::Get | MethodDefinitionKind::Set => {
@@ -49,8 +51,12 @@ impl Compiler {
                             };
                             let key_name = self.class_property_name(&method.key)?;
                             let key_idx = ctx.add_constant(Constant::String(key_name));
-                            ctx.emit(opcode::encode(OpCode::DEFINE_ACCESSOR, home_reg, get_reg, set_reg));
-                            ctx.emit(key_idx as u32);
+                            ctx.inst(Inst::define_accessor(
+                                Operand::Reg(home_reg as u32),
+                                Operand::Reg(get_reg as u32),
+                                Operand::Reg(set_reg as u32),
+                                key_idx as u32,
+                            ));
                         }
                         MethodDefinitionKind::Constructor => continue,
                     }
@@ -62,7 +68,7 @@ impl Compiler {
     }
 
     pub(crate) fn emit_class_method_function(
-        &self, method: &oxide_parser::MethodDefinition, method_name: &str, home_reg: u8, ctx: &mut CompileCtx,
+        &self, method: &oxide_parser::MethodDefinition, method_name: &str, home_reg: Operand, ctx: &mut CompileCtx,
         self_binding: &[(&str, u8)],
     ) -> Result<u8, String> {
         let (param_names, body_stmts) = self.extract_function_parts(method.value.as_ref())?;
@@ -82,10 +88,10 @@ impl Compiler {
         ctx.in_static_method = saved_static;
         method_module.function_name = Some(method_name.to_string());
         method_module.needs_home_object = true;
-        ctx.sub_modules.push(method_module);
+        ctx.nested.push(method_module);
         let method_reg = ctx.alloc_reg();
-        ctx.emit_create_closure(method_reg, ctx.sub_modules.len() as u32);
-        ctx.emit(opcode::encode(OpCode::SET_HOME_OBJECT, method_reg, home_reg, 0));
+        ctx.inst(Inst::create_closure(Operand::Reg(method_reg as u32), ctx.nested.len() as u16));
+        ctx.inst(Inst::new(OpCode::SET_HOME_OBJECT, Operand::Reg(method_reg as u32), home_reg, Operand::None));
         Ok(method_reg)
     }
 }

crates/oxide_compiler/src/class/prototype.rs

@@ -1,33 +1,35 @@
 use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 
 impl Compiler {
     pub(crate) fn emit_class_prototype(
-        &self, ctor_reg: u8, proto_reg: u8, super_reg: Option<u8>, sub_idx: u32, ctx: &mut CompileCtx,
+        &self, ctor_reg: u8, proto_reg: u8, super_reg: Option<u8>, sub_idx: u16, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
-        ctx.emit_create_closure(ctor_reg, sub_idx);
-        ctx.emit(opcode::encode(OpCode::NEW_OBJECT, proto_reg, 0, 0));
+        ctx.inst(Inst::create_closure(Operand::Reg(ctor_reg as u32), sub_idx));
+        ctx.inst(Inst::new(OpCode::NEW_OBJECT, Operand::Reg(proto_reg as u32), Operand::None, Operand::None));
         if let Some(super_reg) = super_reg {
             let proto_key_idx = ctx.add_constant(Constant::String("prototype".to_string()));
             let parent_proto_key_reg = ctx.alloc_reg();
-            ctx.emit_load_const(parent_proto_key_reg, proto_key_idx);
+            ctx.inst(Inst::load_const(Operand::Reg(parent_proto_key_reg as u32), proto_key_idx));
             let parent_proto_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::GET_PROP, super_reg, parent_proto_reg, parent_proto_key_reg));
+            ctx.inst(Inst::new(OpCode::GET_PROP, Operand::Reg(super_reg as u32), Operand::Reg(parent_proto_reg as u32), Operand::Reg(parent_proto_key_reg as u32)));
             let proto_link_idx = ctx.add_constant(Constant::String("__proto__".to_string()));
             let proto_link_key_reg = ctx.alloc_reg();
-            ctx.emit_load_const(proto_link_key_reg, proto_link_idx);
-            ctx.emit(opcode::encode(OpCode::SET_PROP, proto_reg, parent_proto_reg, proto_link_key_reg));
-            ctx.emit(opcode::encode(OpCode::SET_PROP, ctor_reg, super_reg, proto_link_key_reg));
+            ctx.inst(Inst::load_const(Operand::Reg(proto_link_key_reg as u32), proto_link_idx));
+            ctx.inst(Inst::new(OpCode::SET_PROP, Operand::Reg(proto_reg as u32), Operand::Reg(parent_proto_reg as u32), Operand::Reg(proto_link_key_reg as u32)));
+            ctx.inst(Inst::new(OpCode::SET_PROP, Operand::Reg(ctor_reg as u32), Operand::Reg(super_reg as u32), Operand::Reg(proto_link_key_reg as u32)));
         }
         let ctor_key_idx = ctx.add_constant(Constant::String("constructor".to_string()));
         let ctor_key_reg = ctx.alloc_reg();
-        ctx.emit_load_const(ctor_key_reg, ctor_key_idx);
-        ctx.emit(opcode::encode(OpCode::SET_PROP, proto_reg, ctor_reg, ctor_key_reg));
+        ctx.inst(Inst::load_const(Operand::Reg(ctor_key_reg as u32), ctor_key_idx));
+        ctx.inst(Inst::new(OpCode::SET_PROP, Operand::Reg(proto_reg as u32), Operand::Reg(ctor_reg as u32), Operand::Reg(ctor_key_reg as u32)));
         let proto_key_idx = ctx.add_constant(Constant::String("prototype".to_string()));
         let proto_key_reg = ctx.alloc_reg();
-        ctx.emit_load_const(proto_key_reg, proto_key_idx);
-        ctx.emit(opcode::encode(OpCode::SET_PROP, ctor_reg, proto_reg, proto_key_reg));
+        ctx.inst(Inst::load_const(Operand::Reg(proto_key_reg as u32), proto_key_idx));
+        ctx.inst(Inst::new(OpCode::SET_PROP, Operand::Reg(ctor_reg as u32), Operand::Reg(proto_reg as u32), Operand::Reg(proto_key_reg as u32)));
         Ok(())
     }
 }

crates/oxide_compiler/src/compiler.rs

@@ -2,10 +2,14 @@ use std::cell::Cell;
 use std::collections::HashMap;
 
 use crate::emit_ctx::{LabelCtx, ScopeCtx};
+use crate::ir::inst::Inst;
+use crate::ir::lower::lower;
+use crate::ir::operand::{LabelId, Operand};
+use crate::ir::IRFunction;
 use crate::symbol_table::{Binding, SymbolTable};
 use oxide_bytecode::module::CompiledModule;
 use oxide_bytecode::module::UpvalueCapture;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 
 pub use crate::hash::{compiled_module_hash, structural_hash};
 use crate::symbol_table::ScopeKind;
@@ -105,43 +109,9 @@ const BUILTIN_GLOBALS: &[&str] = &[
     "decodeURIComponent",
 ];
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[allow(dead_code)]
-pub(crate) enum Label {
-    IfElse(u32),
-    IfEnd(u32),
-    WhileStart(u32),
-    WhileEnd(u32),
-    ForStart(u32),
-    ForUpdate(u32),
-    ForEnd(u32),
-    TernaryEnd(u32),
-    TernaryElse(u32),
-    DoWhileStart(u32),
-    DoWhileEnd(u32),
-    ForInStart(u32),
-    ForInEnd(u32),
-    ForOfStart(u32),
-    ForOfEnd(u32),
-    SwitchEnd(u32),
-    SwitchCase(u32, u32),
-    CatchBody(u32),
-    FinallyBody(u32),
-    TryEnd(u32),
-    LabeledEnd(u32),
-}
-
-pub(crate) struct JumpFixup {
-    pub(crate) pc: usize,
-    pub(crate) label: Label,
-    pub(crate) opcode: OpCode,
-    pub(crate) rd: u8,
-}
-
 pub(crate) struct FieldBuffer {
-    pub(crate) bytecode: Vec<opcode::Instr>,
-    pub(crate) labels: Vec<(Label, usize)>,
-    pub(crate) fixups: Vec<JumpFixup>,
+    pub(crate) insts: Vec<Inst>,
+    pub(crate) labels: Vec<(LabelId, usize)>,
 }
 
 /// A labeled-statement scope active during emission. `break label` targets
@@ -150,13 +120,12 @@ pub(crate) struct FieldBuffer {
 #[derive(Debug, Clone)]
 pub(crate) struct LabelScope {
     pub(crate) name: String,
-    pub(crate) break_label: Label,
-    pub(crate) continue_label: Option<Label>,
+    pub(crate) break_label: LabelId,
+    pub(crate) continue_label: Option<LabelId>,
 }
 
 pub(crate) struct CompileCtx {
-    pub(crate) bytecode: Vec<opcode::Instr>,
-    pub(crate) fixups: Vec<JumpFixup>,
+    pub(crate) insts: Vec<Inst>,
     pub(crate) constants: Vec<Constant>,
     constant_map: HashMap<ConstantKey, u16>,
     next_reg: u8,
@@ -164,7 +133,7 @@ pub(crate) struct CompileCtx {
     reserved_reg_start: u8,
     pub(crate) labels: LabelCtx,
     pub(crate) scopes: ScopeCtx,
-    pub(crate) sub_modules: Vec<CompiledModule>,
+    pub(crate) nested: Vec<IRFunction>,
     /// Register holding `this` in the enclosing function context.
     /// Used by arrow functions to capture lexical `this`.
     /// Initialized to 254 (conventional this register) at the top level.
@@ -179,7 +148,6 @@ pub(crate) struct CompileCtx {
     /// Checked after each emit phase to produce a compile error rather than silent corruption.
     pub(crate) reg_overflow: bool,
     pub(crate) const_overflow: bool,
-    pub(crate) jump_overflow: bool,
 }
 
 #[derive(Clone, Copy)]
@@ -219,15 +187,14 @@ enum ConstantKey {
 impl CompileCtx {
     pub(crate) fn new() -> Self {
         Self {
-            bytecode: Vec::new(),
-            fixups: Vec::new(),
+            insts: Vec::new(),
             constants: Vec::new(),
             constant_map: HashMap::new(),
             next_reg: 1,
             max_regs: 1,
             reserved_reg_start: 1,
             labels: LabelCtx {
-                label_map: HashMap::new(),
+                label_pos: Vec::new(),
                 loop_stack: Vec::new(),
                 switch_stack: Vec::new(),
                 label_scopes: Vec::new(),
@@ -241,7 +208,7 @@ impl CompileCtx {
                 next_private_name_id: 1,
                 cell_registry: Vec::new(),
             },
-            sub_modules: Vec::new(),
+            nested: Vec::new(),
             enclosing_this_reg: 254, // conventional this register at top level
             in_derived_constructor: false,
             in_instance_method: false,
@@ -251,92 +218,11 @@ impl CompileCtx {
             current_upvalue_captures: Vec::new(),
             reg_overflow: false,
             const_overflow: false,
-            jump_overflow: false,
         }
     }
 
-    pub(crate) fn emit(&mut self, instr: opcode::Instr) {
-        self.bytecode.push(instr);
-    }
-
-    pub(crate) fn emit_load_const(&mut self, reg: u8, idx: u16) {
-        self.emit(opcode::encode(OpCode::LOAD_CONST, reg, (idx & 0xFF) as u8, ((idx >> 8) & 0xFF) as u8));
-    }
-
-    pub(crate) fn emit_create_closure(&mut self, reg: u8, sub_idx: u32) {
-        let idx = sub_idx as u16;
-        self.emit(opcode::encode(OpCode::CREATE_CLOSURE, reg, (idx & 0xFF) as u8, ((idx >> 8) & 0xFF) as u8));
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn emit_jmp_labeled(&mut self, label: Label) {
-        let pc = self.bytecode.len();
-        self.emit(opcode::encode_jmp(0));
-        self.fixups.push(JumpFixup {
-            pc,
-            label,
-            opcode: OpCode::JMP,
-            rd: 0,
-        });
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn emit_jmp_if_false_labeled(&mut self, rd: u8, label: Label) {
-        let pc = self.bytecode.len();
-        self.emit(opcode::encode_jmp_if_false(rd, 0));
-        self.fixups.push(JumpFixup {
-            pc,
-            label,
-            opcode: OpCode::JMP_IF_FALSE,
-            rd,
-        });
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn emit_jmp_if_true_labeled(&mut self, rd: u8, label: Label) {
-        let pc = self.bytecode.len();
-        self.emit(opcode::encode_jmp_if_true(rd, 0));
-        self.fixups.push(JumpFixup {
-            pc,
-            label,
-            opcode: OpCode::JMP_IF_TRUE,
-            rd,
-        });
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn emit_jmp_if_nullish_labeled(&mut self, rd: u8, label: Label) {
-        let pc = self.bytecode.len();
-        self.emit(opcode::encode_jmp_if_nullish(rd, 0));
-        self.fixups.push(JumpFixup {
-            pc,
-            label,
-            opcode: OpCode::JMP_IF_NULLISH,
-            rd,
-        });
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn emit_try_begin_labeled(&mut self, label: Label) {
-        let pc = self.bytecode.len();
-        self.emit(opcode::encode_try_begin(0));
-        self.fixups.push(JumpFixup {
-            pc,
-            label,
-            opcode: OpCode::TRY_BEGIN,
-            rd: 0,
-        });
-    }
-
-    pub(crate) fn emit_try_finally_begin_labeled(&mut self, label: Label) {
-        let pc = self.bytecode.len();
-        self.emit(opcode::encode_try_finally_begin(0));
-        self.fixups.push(JumpFixup {
-            pc,
-            label,
-            opcode: OpCode::TRY_FINALLY_BEGIN,
-            rd: 0,
-        });
+    pub(crate) fn inst(&mut self, inst: Inst) {
+        self.insts.push(inst);
     }
 
     pub(crate) fn alloc_reg(&mut self) -> u8 {
@@ -404,41 +290,6 @@ impl CompileCtx {
         idx as u16
     }
 
-    pub(crate) fn checked_jump_offset(&mut self, offset: isize) -> i16 {
-        if offset < i16::MIN as isize || offset > i16::MAX as isize {
-            self.jump_overflow = true;
-            0
-        } else {
-            offset as i16
-        }
-    }
-
-    pub(crate) fn resolve_label(&self, label: Label) -> Result<usize, String> {
-        self.labels
-            .label_map
-            .get(&label)
-            .copied()
-            .ok_or_else(|| format!("Label {:?} not found in bytecode map", label))
-    }
-
-    pub(crate) fn resolve_fixups(&mut self) -> Result<(), String> {
-        let fixups = std::mem::take(&mut self.fixups);
-        for fixup in fixups {
-            let target_pc = self.resolve_label(fixup.label)?;
-            let offset = self.checked_jump_offset(target_pc as isize - fixup.pc as isize);
-            self.bytecode[fixup.pc] = match fixup.opcode {
-                OpCode::JMP => opcode::encode_jmp(offset),
-                OpCode::JMP_IF_FALSE => opcode::encode_jmp_if_false(fixup.rd, offset),
-                OpCode::JMP_IF_TRUE => opcode::encode_jmp_if_true(fixup.rd, offset),
-                OpCode::JMP_IF_NULLISH => opcode::encode_jmp_if_nullish(fixup.rd, offset),
-                OpCode::TRY_BEGIN => opcode::encode_try_begin(offset),
-                OpCode::TRY_FINALLY_BEGIN => opcode::encode_try_finally_begin(offset),
-                _ => return Err(format!("Unsupported fixup opcode {:?}", fixup.opcode)),
-            };
-        }
-        Ok(())
-    }
-
     pub(crate) fn push_scope(&mut self) {
         self.scopes.symbols.push_scope();
     }
@@ -503,7 +354,7 @@ impl CompileCtx {
         id
     }
 
-    pub(crate) fn push_loop(&mut self, break_label: Label, continue_label: Label) {
+    pub(crate) fn push_loop(&mut self, break_label: LabelId, continue_label: LabelId) {
         self.labels.loop_stack.push((break_label, continue_label));
     }
 
@@ -511,11 +362,11 @@ impl CompileCtx {
         self.labels.loop_stack.pop();
     }
 
-    pub(crate) fn current_loop(&self) -> Option<&(Label, Label)> {
+    pub(crate) fn current_loop(&self) -> Option<&(LabelId, LabelId)> {
         self.labels.loop_stack.last()
     }
 
-    pub(crate) fn push_switch(&mut self, break_label: Label) {
+    pub(crate) fn push_switch(&mut self, break_label: LabelId) {
         self.labels.switch_stack.push(break_label);
     }
 
@@ -523,12 +374,12 @@ impl CompileCtx {
         self.labels.switch_stack.pop();
     }
 
-    pub(crate) fn current_switch(&self) -> Option<&Label> {
+    pub(crate) fn current_switch(&self) -> Option<&LabelId> {
         self.labels.switch_stack.last()
     }
 
     pub(crate) fn push_label_scope(
-        &mut self, name: &str, break_label: Label, continue_label: Option<Label>,
+        &mut self, name: &str, break_label: LabelId, continue_label: Option<LabelId>,
     ) -> Result<(), String> {
         if self.labels.label_scopes.iter().any(|s| s.name == name) {
             return Err(format!("SyntaxError: Label '{name}' has already been declared"));
@@ -564,7 +415,7 @@ impl CompileCtx {
 
     /// Drain queued loop labels into active scopes bound to this loop's break and
     /// continue targets. Returns how many scopes were pushed (to pop after).
-    pub(crate) fn take_pending_loop_labels(&mut self, break_label: Label, continue_label: Label) -> usize {
+    pub(crate) fn take_pending_loop_labels(&mut self, break_label: LabelId, continue_label: LabelId) -> usize {
         let names = std::mem::take(&mut self.labels.pending_loop_labels);
         let count = names.len();
         for name in names {
@@ -880,7 +731,7 @@ impl Compiler {
     pub(crate) fn compile_function_body<'a>(
         &self, param_specs: &[ParamSpec<'a>], body_stmts: &[Statement<'a>], parent_ctx: &CompileCtx,
         is_expression_body: bool, is_arrow: bool,
-    ) -> Result<CompiledModule, String> {
+    ) -> Result<IRFunction, String> {
         let body_context = if is_arrow {
             FunctionBodyContext::Arrow
         } else {
@@ -899,7 +750,7 @@ impl Compiler {
     pub(crate) fn compile_function_body_with_bindings<'a>(
         &self, param_specs: &[ParamSpec<'a>], body_stmts: &[Statement<'a>], parent_ctx: &CompileCtx,
         is_expression_body: bool, extra_bindings: &[(&str, u8)], body_context: FunctionBodyContext,
-    ) -> Result<CompiledModule, String> {
+    ) -> Result<IRFunction, String> {
         self.compile_function_body_with_field_hooks(
             param_specs,
             body_stmts,
@@ -1355,7 +1206,7 @@ impl Compiler {
         &self, param_specs: &[ParamSpec<'a>], body_stmts: &[Statement<'a>], parent_ctx: &CompileCtx,
         is_expression_body: bool, extra_bindings: &[(&str, u8)], body_context: FunctionBodyContext,
         mut emit_fields: Option<E>, fields_after_super: bool,
-    ) -> Result<CompiledModule, String>
+    ) -> Result<IRFunction, String>
     where
         E: FnMut(&Compiler, &mut CompileCtx) -> Result<(), String>,
     {
@@ -1464,21 +1315,21 @@ impl Compiler {
 
         if let Some(emit) = emit_fields.as_mut() {
             if fields_after_super {
-                let mut parent_bytecode = Vec::new();
-                let mut parent_labels = HashMap::new();
-                let mut parent_fixups = Vec::new();
-                std::mem::swap(&mut ctx.bytecode, &mut parent_bytecode);
-                std::mem::swap(&mut ctx.labels.label_map, &mut parent_labels);
-                std::mem::swap(&mut ctx.fixups, &mut parent_fixups);
+                let mut parent_insts = Vec::new();
+                let mut parent_label_pos = Vec::new();
+                std::mem::swap(&mut ctx.insts, &mut parent_insts);
+                std::mem::swap(&mut ctx.labels.label_pos, &mut parent_label_pos);
                 emit(self, &mut ctx)?;
                 let field_buffer = FieldBuffer {
-                    bytecode: std::mem::take(&mut ctx.bytecode),
-                    labels: std::mem::take(&mut ctx.labels.label_map).into_iter().collect(),
-                    fixups: std::mem::take(&mut ctx.fixups),
+                    insts: std::mem::take(&mut ctx.insts),
+                    labels: std::mem::take(&mut ctx.labels.label_pos)
+                        .into_iter()
+                        .enumerate()
+                        .filter_map(|(id, pos)| pos.map(|p| (id as LabelId, p)))
+                        .collect(),
                 };
-                ctx.bytecode = parent_bytecode;
-                ctx.labels.label_map = parent_labels;
-                ctx.fixups = parent_fixups;
+                ctx.insts = parent_insts;
+                ctx.labels.label_pos = parent_label_pos;
                 ctx.field_buffer = Some(field_buffer);
             } else {
                 emit(self, &mut ctx)?;
@@ -1505,60 +1356,33 @@ impl Compiler {
             }
         }
 
-        ctx.resolve_fixups()?;
-
         // Emit implicit RETURN: expression body returns the last expression,
         // statement body returns undefined.
         if is_expression_body {
             if let Some(reg) = last_result_reg {
-                ctx.emit(opcode::encode(OpCode::RETURN, reg, 0, 0));
+                ctx.inst(Inst::new(OpCode::RETURN, Operand::Reg(reg as u32), Operand::None, Operand::None));
             } else {
                 let undef_idx = ctx.add_constant(Constant::Undefined);
                 let undef_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(
-                    OpCode::LOAD_CONST,
-                    undef_reg,
-                    (undef_idx & 0xFF) as u8,
-                    ((undef_idx >> 8) & 0xFF) as u8,
-                ));
-                ctx.emit(opcode::encode(OpCode::RETURN, undef_reg, 0, 0));
+                ctx.inst(Inst::load_const(Operand::Reg(undef_reg as u32), undef_idx));
+                ctx.inst(Inst::new(OpCode::RETURN, Operand::Reg(undef_reg as u32), Operand::None, Operand::None));
             }
         } else {
             let undef_idx = ctx.add_constant(Constant::Undefined);
             let undef_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(
-                OpCode::LOAD_CONST,
-                undef_reg,
-                (undef_idx & 0xFF) as u8,
-                ((undef_idx >> 8) & 0xFF) as u8,
-            ));
-            ctx.emit(opcode::encode(OpCode::RETURN, undef_reg, 0, 0));
+            ctx.inst(Inst::load_const(Operand::Reg(undef_reg as u32), undef_idx));
+            ctx.inst(Inst::new(OpCode::RETURN, Operand::Reg(undef_reg as u32), Operand::None, Operand::None));
         }
 
-        if ctx.reg_overflow {
-            return Err("RangeError: function body uses too many registers (max 253)".into());
-        }
-        if ctx.const_overflow {
-            return Err("RangeError: too many constants".into());
-        }
-        if ctx.jump_overflow {
-            return Err("RangeError: jump offset out of range".into());
-        }
-
-        Ok(CompiledModule {
-            bytecode: ctx.bytecode,
+        let ir = IRFunction {
+            insts: ctx.insts,
+            label_pos: ctx.labels.label_pos,
+            label_count: ctx.labels.label_counter,
             constants: ctx.constants,
-            n_registers: ctx.max_regs,
-            n_args: param_specs.len() as u8,
-            param_base,
-            builtin_reg_map: ctx.scopes.builtin_reg_map,
-            sub_modules: ctx.sub_modules,
-            is_arrow: false,
-            captured_this_const_idx: 0,
-            function_name: None,
-            is_class_constructor: false,
-            is_derived_constructor: false,
-            needs_home_object: false,
+            param_layout: crate::ir::ParamLayout {
+                base: param_base as u32,
+                count: param_specs.len() as u32,
+            },            builtin_reg_map: ctx.scopes.builtin_reg_map,
             upvalue_captures: ctx.current_upvalue_captures.clone(),
             cells_needed: ctx
                 .scopes
@@ -1568,7 +1392,18 @@ impl Compiler {
                 .flat_map(|s| s.bindings.values())
                 .filter(|b| b.is_captured.get())
                 .count() as u8,
-        })
+            n_registers: ctx.max_regs,
+            is_arrow: false,
+            is_class_constructor: false,
+            is_derived_constructor: false,
+            needs_home_object: false,
+            captured_this_const_idx: 0,
+            function_name: None,
+            reg_overflow: ctx.reg_overflow,
+            const_overflow: ctx.const_overflow,
+            nested: ctx.nested,
+        };
+        Ok(ir)
     }
 
     pub(crate) fn emit_statement(&self, stmt: &Statement, ctx: &mut CompileCtx) -> Result<Option<u8>, String> {
@@ -1663,48 +1498,26 @@ impl Compiler {
                 None => last_result = None,
             }
         }
-        ctx.resolve_fixups()?;
-        crate::compiler_debug!("emitter: {} bytes emitted", ctx.bytecode.len());
-
         if let Some(r) = last_result {
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, 0, r, 0));
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::None, Operand::Reg(r as u32), Operand::None));
         } else {
             let undef_idx = ctx.add_constant(Constant::Undefined);
-            ctx.emit(opcode::encode(
-                OpCode::LOAD_CONST,
-                0,
-                (undef_idx & 0xFF) as u8,
-                ((undef_idx >> 8) & 0xFF) as u8,
-            ));
+            ctx.inst(Inst::load_const(Operand::None, undef_idx));
         }
-        ctx.emit(opcode::encode(OpCode::HALT, 0, 0, 0));
+        ctx.inst(Inst::new(OpCode::HALT, Operand::None, Operand::None, Operand::None));
 
-        if ctx.reg_overflow {
-            return Err("RangeError: function body uses too many registers (max 253)".into());
-        }
-        if ctx.const_overflow {
-            return Err("RangeError: too many constants".into());
-        }
-        if ctx.jump_overflow {
-            return Err("RangeError: jump offset out of range".into());
-        }
+        crate::compiler_debug!("compile: done, {} instructions, {} constants", ctx.insts.len(), ctx.constants.len());
 
-        crate::compiler_debug!("compile: done, {} instructions, {} constants", ctx.bytecode.len(), ctx.constants.len());
-
-        Ok(CompiledModule {
-            bytecode: ctx.bytecode,
+        let ir = IRFunction {
+            insts: ctx.insts,
+            label_pos: ctx.labels.label_pos,
+            label_count: ctx.labels.label_counter,
             constants: ctx.constants,
-            n_registers: ctx.max_regs,
-            n_args: 0,
-            param_base: ctx.scopes.builtin_reg_map.len() as u8,
+            param_layout: crate::ir::ParamLayout {
+                base: ctx.scopes.builtin_reg_map.len() as u32,
+                count: 0,
+            },
             builtin_reg_map: ctx.scopes.builtin_reg_map,
-            sub_modules: ctx.sub_modules,
-            is_arrow: false,
-            captured_this_const_idx: 0,
-            function_name: None,
-            is_class_constructor: false,
-            is_derived_constructor: false,
-            needs_home_object: false,
             upvalue_captures: ctx.current_upvalue_captures.clone(),
             cells_needed: ctx
                 .scopes
@@ -1714,7 +1527,18 @@ impl Compiler {
                 .flat_map(|s| s.bindings.values())
                 .filter(|b| b.is_captured.get())
                 .count() as u8,
-        })
+            n_registers: ctx.max_regs,
+            is_arrow: false,
+            is_class_constructor: false,
+            is_derived_constructor: false,
+            needs_home_object: false,
+            captured_this_const_idx: 0,
+            function_name: None,
+            reg_overflow: ctx.reg_overflow,
+            const_overflow: ctx.const_overflow,
+            nested: ctx.nested,
+        };
+        lower(&ir)
     }
 }
 
@@ -1723,16 +1547,3 @@ impl Default for Compiler {
         Self::new()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::CompileCtx;
-
-    #[test]
-    fn test_jump_offset_overflow_range_error() {
-        let mut ctx = CompileCtx::new();
-        let offset = ctx.checked_jump_offset(i16::MAX as isize + 1);
-        assert_eq!(offset, 0);
-        assert!(ctx.jump_overflow);
-    }
-}

crates/oxide_compiler/src/emit_ctx.rs

@@ -3,20 +3,20 @@
 //! Splits the compiler's central `CompileCtx` so syntax-domain workers borrow
 //! only the slice they need: `LabelCtx` for jump-target resolution, `ScopeCtx`
 //! for identifier binding. `PatternCtx` is reserved for destructuring work.
-//! Execution-stream fields (bytecode, registers, pc, …) stay flat on
+//! Execution-stream fields (insts, registers, pc, …) stay flat on
 //! `CompileCtx`.
 
-use std::collections::HashMap;
-
-use crate::compiler::{Label, LabelScope};
+use crate::compiler::LabelScope;
+use crate::ir::operand::LabelId;
 use crate::symbol_table::SymbolTable;
 
 /// Jump-target / labeled-statement resolution state.
 pub(crate) struct LabelCtx {
-    pub(crate) label_map: HashMap<Label, usize>,
-    pub(crate) loop_stack: Vec<(Label, Label)>,
+    /// label id → 指令下标。id 连续递增，Vec 索引即 id；写入前须扩容。
+    pub(crate) label_pos: Vec<Option<usize>>,
+    pub(crate) loop_stack: Vec<(LabelId, LabelId)>,
     #[allow(dead_code)]
-    pub(crate) switch_stack: Vec<Label>,
+    pub(crate) switch_stack: Vec<LabelId>,
     /// Active labeled-statement scopes (resolves `break label` / `continue label`).
     pub(crate) label_scopes: Vec<LabelScope>,
     /// Label names awaiting binding to the next emitted loop's continue target.
@@ -24,6 +24,16 @@ pub(crate) struct LabelCtx {
     pub(crate) label_counter: u32,
 }
 
+impl LabelCtx {
+    /// 按 id 扩容后写入 label 定义位置。
+    pub(crate) fn set_label_pos(&mut self, id: LabelId, pos: usize) {
+        if id as usize >= self.label_pos.len() {
+            self.label_pos.resize(id as usize + 1, None);
+        }
+        self.label_pos[id as usize] = Some(pos);
+    }
+}
+
 /// Identifier-binding state: symbols, builtin registers, private names.
 pub(crate) struct ScopeCtx {
     pub(crate) symbols: SymbolTable,

crates/oxide_compiler/src/expr/assignment.rs

@@ -1,39 +1,32 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::AssignmentOperator;
 
-impl Compiler {}
-
 impl Compiler {
     pub(crate) fn emit_assignment_expression(
         &self, assign: &oxide_parser::AssignmentExpression, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
         if let oxide_parser::AssignmentTarget::StaticMemberExpression(member) = &assign.left {
             if let Some(logical_op) = assign.operator.to_logical_operator() {
-                let id = ctx.next_label_id();
-                let store_label = Label::TernaryElse(id);
-                let end_label = Label::TernaryEnd(id);
+                let store_label = ctx.next_label_id();
+                let end_label = ctx.next_label_id();
                 let obj_reg = self.emit_expression(&member.object, ctx)?;
                 let prop_name = member.property.name.as_str();
                 let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
                 let key_reg = ctx.alloc_reg();
-                ctx.emit_load_const(key_reg, idx);
+                ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
                 let result_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, obj_reg, 0));
-                ctx.emit(opcode::encode(OpCode::IC_GET_PROP, 0, result_reg, key_reg));
-                ctx.emit(0);
-                ctx.emit(0);
-                ctx.emit(0);
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(obj_reg as u32), Operand::None));
+                ctx.inst(Inst::ic_get(Operand::Reg(result_reg as u32), Operand::Reg(key_reg as u32)));
                 self.emit_logical_assign_test(logical_op, result_reg, store_label, end_label, ctx)?;
-                ctx.labels.label_map.insert(store_label, ctx.bytecode.len());
+                ctx.labels.set_label_pos(store_label, ctx.insts.len());
                 let val_reg = self.emit_expression(&assign.right, ctx)?;
-                ctx.emit(opcode::encode(OpCode::IC_SET_PROP, obj_reg, val_reg, key_reg));
-                ctx.emit(0);
-                ctx.emit(0);
-                ctx.emit(0);
-                ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, val_reg, 0));
-                ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+                ctx.inst(Inst::ic_set(Operand::Reg(obj_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(key_reg as u32)));
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(val_reg as u32), Operand::None));
+                ctx.labels.set_label_pos(end_label, ctx.insts.len());
                 return Ok(result_reg);
             }
             let obj_reg = self.emit_expression(&member.object, ctx)?;
@@ -41,50 +34,45 @@ impl Compiler {
             let prop_name = member.property.name.as_str();
             let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
             let key_reg = ctx.alloc_reg();
-            ctx.emit_load_const(key_reg, idx);
+            ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
             if assign.operator != AssignmentOperator::Assign {
-                let op = match assign.operator {
-                    AssignmentOperator::Addition => OpCode::COMPOUND_MEMBER_ADD,
-                    AssignmentOperator::Subtraction => OpCode::COMPOUND_MEMBER_SUB,
-                    AssignmentOperator::Multiplication => OpCode::COMPOUND_MEMBER_MUL,
-                    AssignmentOperator::Division => OpCode::COMPOUND_MEMBER_DIV,
-                    AssignmentOperator::Remainder => OpCode::COMPOUND_MEMBER_MOD,
-                    AssignmentOperator::Exponential => OpCode::COMPOUND_MEMBER_EXP,
+                let obj = Operand::Reg(obj_reg as u32);
+                let val = Operand::Reg(val_reg as u32);
+                let key = Operand::Reg(key_reg as u32);
+                match assign.operator {
+                    AssignmentOperator::Addition => ctx.inst(Inst::compound_member_add(obj, val, key)),
+                    AssignmentOperator::Subtraction => ctx.inst(Inst::compound_member_sub(obj, val, key)),
+                    AssignmentOperator::Multiplication => ctx.inst(Inst::compound_member_mul(obj, val, key)),
+                    AssignmentOperator::Division => ctx.inst(Inst::compound_member_div(obj, val, key)),
+                    AssignmentOperator::Remainder => ctx.inst(Inst::compound_member_mod(obj, val, key)),
+                    AssignmentOperator::Exponential => ctx.inst(Inst::compound_member_exp(obj, val, key)),
                     _ => return Err(format!("compound assignment operator {:?} not supported", assign.operator)),
-                };
-                ctx.emit(opcode::encode(op, obj_reg, val_reg, key_reg));
-                ctx.emit(0);
-                ctx.emit(0);
-                ctx.emit(0);
+                }
                 Ok(val_reg)
             } else {
-                ctx.emit(opcode::encode(OpCode::IC_SET_PROP, obj_reg, val_reg, key_reg));
-                ctx.emit(0);
-                ctx.emit(0);
-                ctx.emit(0);
+                ctx.inst(Inst::ic_set(Operand::Reg(obj_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(key_reg as u32)));
                 Ok(val_reg)
             }
         } else if let oxide_parser::AssignmentTarget::ComputedMemberExpression(member) = &assign.left {
             if let Some(logical_op) = assign.operator.to_logical_operator() {
-                let id = ctx.next_label_id();
-                let store_label = Label::TernaryElse(id);
-                let end_label = Label::TernaryEnd(id);
+                let store_label = ctx.next_label_id();
+                let end_label = ctx.next_label_id();
                 let obj_reg = self.emit_expression(&member.object, ctx)?;
                 let key_reg = self.emit_expression(&member.expression, ctx)?;
                 let result_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::GET_PROP_DYNAMIC, obj_reg, key_reg, result_reg));
+                ctx.inst(Inst::new(OpCode::GET_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(result_reg as u32)));
                 self.emit_logical_assign_test(logical_op, result_reg, store_label, end_label, ctx)?;
-                ctx.labels.label_map.insert(store_label, ctx.bytecode.len());
+                ctx.labels.set_label_pos(store_label, ctx.insts.len());
                 let val_reg = self.emit_expression(&assign.right, ctx)?;
-                ctx.emit(opcode::encode(OpCode::SET_PROP_DYNAMIC, obj_reg, key_reg, val_reg));
-                ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, val_reg, 0));
-                ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+                ctx.inst(Inst::new(OpCode::SET_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(val_reg as u32)));
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(val_reg as u32), Operand::None));
+                ctx.labels.set_label_pos(end_label, ctx.insts.len());
                 return Ok(result_reg);
             }
             let obj_reg = self.emit_expression(&member.object, ctx)?;
             let key_reg = self.emit_expression(&member.expression, ctx)?;
             let val_reg = self.emit_expression(&assign.right, ctx)?;
-            ctx.emit(opcode::encode(OpCode::SET_PROP_DYNAMIC, obj_reg, key_reg, val_reg));
+            ctx.inst(Inst::new(OpCode::SET_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(val_reg as u32)));
             Ok(val_reg)
         } else if let oxide_parser::AssignmentTarget::PrivateFieldExpression(member) = &assign.left {
             if assign.operator != AssignmentOperator::Assign {
@@ -93,26 +81,25 @@ impl Compiler {
             let obj_reg = self.emit_expression(&member.object, ctx)?;
             let val_reg = self.emit_expression(&assign.right, ctx)?;
             let key_reg = self.emit_private_id_reg(member.field.name.as_str(), ctx)?;
-            ctx.emit(opcode::encode(OpCode::SET_PRIVATE, obj_reg, val_reg, key_reg));
+            ctx.inst(Inst::new(OpCode::SET_PRIVATE, Operand::Reg(obj_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(key_reg as u32)));
             Ok(val_reg)
         } else if let oxide_parser::AssignmentTarget::AssignmentTargetIdentifier(id_ref) = &assign.left {
             if assign.operator != AssignmentOperator::Assign {
                 if let Some(logical_op) = assign.operator.to_logical_operator() {
-                    let id = ctx.next_label_id();
-                    let store_label = Label::TernaryElse(id);
-                    let end_label = Label::TernaryEnd(id);
+                    let store_label = ctx.next_label_id();
+                    let end_label = ctx.next_label_id();
                     let name = id_ref.name.as_str();
                     let var_reg = ctx.lookup_or_global(name);
                     let result_reg = ctx.alloc_reg();
-                    ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, var_reg, 0));
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(var_reg as u32), Operand::None));
                     self.emit_logical_assign_test(logical_op, result_reg, store_label, end_label, ctx)?;
-                    ctx.labels.label_map.insert(store_label, ctx.bytecode.len());
+                    ctx.labels.set_label_pos(store_label, ctx.insts.len());
                     let val_reg = self.emit_expression(&assign.right, ctx)?;
                     let is_const = ctx.lookup_const_flag(name);
                     let const_flag = if is_const { 1 } else { 0 };
-                    ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, val_reg, const_flag));
-                    ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, val_reg, 0));
-                    ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+                    ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(val_reg as u32), Operand::Imm(const_flag)));
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(val_reg as u32), Operand::None));
+                    ctx.labels.set_label_pos(end_label, ctx.insts.len());
                     Ok(result_reg)
                 } else if assign.operator == AssignmentOperator::Addition
                     || assign.operator == AssignmentOperator::Subtraction
@@ -145,7 +132,7 @@ impl Compiler {
                         AssignmentOperator::ShiftRightZeroFill => OpCode::COMPOUND_USHR,
                         _ => return Err(format!("compound assignment operator {:?} not supported", assign.operator)),
                     };
-                    ctx.emit(opcode::encode(op, var_reg, rhs, 0));
+                    ctx.inst(Inst::new(op, Operand::Reg(var_reg as u32), Operand::Reg(rhs as u32), Operand::None));
                     Ok(var_reg)
                 } else {
                     Err(format!("compound assignment operator {:?} not supported", assign.operator))
@@ -155,7 +142,7 @@ impl Compiler {
                 let name = id_ref.name.as_str();
                 // Check if target is an upvalue reference
                 if let Some(uv_idx) = ctx.current_upvalue_captures.iter().position(|u| u.name == name) {
-                    ctx.emit(opcode::encode(OpCode::STORE_UPVALUE, 0, val_reg, uv_idx as u8));
+                    ctx.inst(Inst::new(OpCode::STORE_UPVALUE, Operand::None, Operand::Reg(val_reg as u32), Operand::Imm(uv_idx as u16)));
                     return Ok(val_reg);
                 }
                 // Check if target is a captured cell
@@ -167,13 +154,13 @@ impl Compiler {
                         .find(|(n, _)| n == name)
                         .map(|(_, idx)| *idx)
                         .unwrap_or(0);
-                    ctx.emit(opcode::encode(OpCode::CELL_SET, 0, val_reg, cell_idx));
+                    ctx.inst(Inst::new(OpCode::CELL_SET, Operand::None, Operand::Reg(val_reg as u32), Operand::Imm(cell_idx as u16)));
                     return Ok(val_reg);
                 }
                 let var_reg = ctx.lookup_or_global(name);
                 let is_const = ctx.lookup_const_flag(name);
                 let const_flag = if is_const { 1 } else { 0 };
-                ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, val_reg, const_flag));
+                ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(val_reg as u32), Operand::Imm(const_flag)));
                 Ok(val_reg)
             }
         } else if matches!(

crates/oxide_compiler/src/expr/call.rs

@@ -1,6 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Expression;
 
 impl Compiler {
@@ -17,17 +19,16 @@ impl Compiler {
             }
             let first_arg_reg = if arg_regs.is_empty() { 0u8 } else { arg_regs[0] };
             let result_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::SUPER_CALL, result_reg, first_arg_reg, 0));
-            ctx.emit(arg_regs.len() as u32);
+            ctx.inst(Inst::super_call(
+                Operand::Reg(result_reg as u32),
+                Operand::Reg(first_arg_reg as u32),
+                arg_regs.len() as u8,
+            ));
             if let Some(mut field_buffer) = ctx.field_buffer.take() {
-                let insert_pc = ctx.bytecode.len();
-                ctx.bytecode.append(&mut field_buffer.bytecode);
-                for (label, relative_pc) in field_buffer.labels {
-                    ctx.labels.label_map.insert(label, insert_pc + relative_pc);
-                }
-                for mut fixup in field_buffer.fixups {
-                    fixup.pc += insert_pc;
-                    ctx.fixups.push(fixup);
+                let insert_inst = ctx.insts.len();
+                ctx.insts.append(&mut field_buffer.insts);
+                for (label, relative) in field_buffer.labels {
+                    ctx.labels.set_label_pos(label, insert_inst + relative);
                 }
             }
             return Ok(result_reg);
@@ -37,14 +38,14 @@ impl Compiler {
                 let obj_reg = self.emit_expression(&member.object, ctx)?;
                 let key_reg = self.emit_private_id_reg(member.field.name.as_str(), ctx)?;
                 let callee_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::GET_PRIVATE, callee_reg, obj_reg, key_reg));
+                ctx.inst(Inst::new(OpCode::GET_PRIVATE, Operand::Reg(callee_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                 (callee_reg, obj_reg)
             }
             Expression::StaticMemberExpression(member) => {
                 let is_super_member = matches!(&member.object, Expression::Super(_));
                 let obj_reg = if is_super_member {
                     let this_reg = ctx.alloc_reg();
-                    ctx.emit(opcode::encode(OpCode::LOAD_VAR, this_reg, 254, 0));
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(this_reg as u32), Operand::This, Operand::None));
                     this_reg
                 } else {
                     self.emit_expression(&member.object, ctx)?
@@ -52,7 +53,7 @@ impl Compiler {
                 let prop_name = member.property.name.as_str();
                 let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
                 let key_reg = ctx.alloc_reg();
-                ctx.emit_load_const(key_reg, idx);
+                ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
                 let callee_reg = ctx.alloc_reg();
                 if is_super_member {
                     if !ctx.in_instance_method && !ctx.in_static_method && !ctx.in_derived_constructor {
@@ -63,13 +64,10 @@ impl Compiler {
                     } else {
                         OpCode::SUPER_GET_PROP
                     };
-                    ctx.emit(opcode::encode(op, callee_reg, obj_reg, key_reg));
+                    ctx.inst(Inst::new(op, Operand::Reg(callee_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                 } else {
-                    ctx.emit(opcode::encode(OpCode::LOAD_VAR, callee_reg, obj_reg, 0));
-                    ctx.emit(opcode::encode(OpCode::IC_GET_PROP, 0, callee_reg, key_reg));
-                    ctx.emit(0);
-                    ctx.emit(0);
-                    ctx.emit(0);
+                    ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(callee_reg as u32), Operand::Reg(obj_reg as u32), Operand::None));
+                    ctx.inst(Inst::ic_get(Operand::Reg(callee_reg as u32), Operand::Reg(key_reg as u32)));
                 }
                 (callee_reg, obj_reg)
             }
@@ -77,7 +75,7 @@ impl Compiler {
                 let callee_reg = self.emit_expression(&call.callee, ctx)?;
                 let this_idx = ctx.add_constant(Constant::Undefined);
                 let this_reg = ctx.alloc_reg();
-                ctx.emit_load_const(this_reg, this_idx);
+                ctx.inst(Inst::load_const(Operand::Reg(this_reg as u32), this_idx));
                 (callee_reg, this_reg)
             }
         };
@@ -92,10 +90,27 @@ impl Compiler {
             Expression::Identifier(ident) if ctx.is_builtin(ident.name.as_str()) => OpCode::CALL_NATIVE,
             _ => OpCode::CALL,
         };
-        ctx.emit(opcode::encode(op, callee_reg, this_reg, first_arg_reg));
-        ctx.emit(arg_regs.len() as u32);
+        match op {
+            OpCode::CALL => {
+                ctx.inst(Inst::call(
+                    Operand::Reg(callee_reg as u32),
+                    Operand::Reg(this_reg as u32),
+                    Operand::Reg(first_arg_reg as u32),
+                    arg_regs.len() as u8,
+                ));
+            }
+            OpCode::CALL_NATIVE => {
+                ctx.inst(Inst::call_native(
+                    Operand::Reg(callee_reg as u32),
+                    Operand::Reg(this_reg as u32),
+                    Operand::Reg(first_arg_reg as u32),
+                    arg_regs.len() as u8,
+                ));
+            }
+            _ => unreachable!(),
+        }
         let result_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::None, Operand::None));
         Ok(result_reg)
     }
 

crates/oxide_compiler/src/expr/function/mod.rs

@@ -1,5 +1,6 @@
 use crate::compiler::{CompileCtx, Compiler, ParamSpec};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_parser::{Class, Expression, Statement};
 
 impl Compiler {
@@ -35,12 +36,12 @@ impl Compiler {
         let mut sub_module = self.compile_function_body(&param_names, body_stmts, ctx, is_expr_body, true)?;
         sub_module.is_arrow = true;
 
-        ctx.sub_modules.push(sub_module);
+        ctx.nested.push(sub_module);
         // 1-indexed: 0 = no sub_module (sentinel)
-        let sub_idx = ctx.sub_modules.len() as u32;
+        let sub_idx = ctx.nested.len() as u16;
 
         let r = ctx.alloc_reg();
-        ctx.emit_create_closure(r, sub_idx);
+        ctx.inst(Inst::create_closure(Operand::Reg(r as u32), sub_idx));
         Ok(r)
     }
 
@@ -67,12 +68,12 @@ impl Compiler {
         if let Some(id) = &fe.id {
             sub_module.function_name = Some(id.name.to_string());
         }
-        ctx.sub_modules.push(sub_module);
+        ctx.nested.push(sub_module);
         // 1-indexed: 0 = no sub_module (sentinel)
-        let sub_idx = ctx.sub_modules.len() as u32;
+        let sub_idx = ctx.nested.len() as u16;
 
         let r = ctx.alloc_reg();
-        ctx.emit_create_closure(r, sub_idx);
+        ctx.inst(Inst::create_closure(Operand::Reg(r as u32), sub_idx));
         Ok(r)
     }
 
@@ -90,8 +91,12 @@ impl Compiler {
         }
         let first_arg_reg = if arg_regs.is_empty() { 0u8 } else { arg_regs[0] };
         let r = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::NEW_EXPRESSION, r, constructor_reg, first_arg_reg));
-        ctx.emit(arg_regs.len() as u32);
+        ctx.inst(Inst::new_expression(
+            Operand::Reg(r as u32),
+            Operand::Reg(constructor_reg as u32),
+            Operand::Reg(first_arg_reg as u32),
+            arg_regs.len() as u8,
+        ));
         Ok(r)
     }
 

crates/oxide_compiler/src/expr/identifier.rs

@@ -1,5 +1,7 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 
 impl Compiler {
     pub(crate) fn emit_identifier_expression(
@@ -11,7 +13,7 @@ impl Compiler {
             if up.name == name {
                 let r = ctx.alloc_reg();
                 let idx = uv_idx as u8;
-                ctx.emit(opcode::encode(OpCode::LOAD_UPVALUE, r, idx, 0));
+                ctx.inst(Inst::new(OpCode::LOAD_UPVALUE, Operand::Reg(r as u32), Operand::Reg(idx as u32), Operand::None));
                 return Ok(r);
             }
         }
@@ -26,16 +28,16 @@ impl Compiler {
                 .unwrap_or(0);
             let r = ctx.alloc_reg();
             if let Some((binding, _)) = ctx.scopes.symbols.lookup_any_binding(name) {
-                ctx.emit(opcode::encode(OpCode::CELL_GET, r, binding.reg, cell_idx));
+                ctx.inst(Inst::new(OpCode::CELL_GET, Operand::Reg(r as u32), Operand::Reg(binding.reg as u32), Operand::Reg(cell_idx as u32)));
             } else {
-                ctx.emit(opcode::encode(OpCode::CELL_GET, r, 0, cell_idx));
+                ctx.inst(Inst::new(OpCode::CELL_GET, Operand::Reg(r as u32), Operand::None, Operand::Reg(cell_idx as u32)));
             }
             return Ok(r);
         }
 
         let var_reg = ctx.lookup_or_builtin(name)?;
         let r = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, r, var_reg, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(r as u32), Operand::Reg(var_reg as u32), Operand::None));
         Ok(r)
     }
 }

crates/oxide_compiler/src/expr/literal.rs

@@ -1,6 +1,8 @@
 use crate::compiler::{is_int_literal, CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Expression;
 
 impl Compiler {
@@ -24,7 +26,7 @@ impl Compiler {
             ctx.add_constant(Constant::Number(n.value))
         };
         let r = ctx.alloc_reg();
-        ctx.emit_load_const(r, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(r as u32), idx));
         Ok(r)
     }
 
@@ -33,7 +35,7 @@ impl Compiler {
     ) -> Result<u8, String> {
         let idx = ctx.add_constant(Constant::String(s.value.to_string()));
         let r = ctx.alloc_reg();
-        ctx.emit_load_const(r, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(r as u32), idx));
         Ok(r)
     }
 
@@ -42,14 +44,14 @@ impl Compiler {
     ) -> Result<u8, String> {
         let idx = ctx.add_constant(Constant::Boolean(b.value));
         let r = ctx.alloc_reg();
-        ctx.emit_load_const(r, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(r as u32), idx));
         Ok(r)
     }
 
     fn emit_null_literal_expression(&self, ctx: &mut CompileCtx) -> Result<u8, String> {
         let idx = ctx.add_constant(Constant::Null);
         let r = ctx.alloc_reg();
-        ctx.emit_load_const(r, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(r as u32), idx));
         Ok(r)
     }
 
@@ -64,12 +66,12 @@ impl Compiler {
                 let flags = raw_str[last_slash + 1..].to_string();
                 let pat_ci = ctx.add_constant(Constant::String(pattern));
                 let pat_reg = ctx.alloc_reg();
-                ctx.emit_load_const(pat_reg, pat_ci);
+                ctx.inst(Inst::load_const(Operand::Reg(pat_reg as u32), pat_ci));
                 let flags_ci = ctx.add_constant(Constant::String(flags));
                 let flags_reg = ctx.alloc_reg();
-                ctx.emit_load_const(flags_reg, flags_ci);
+                ctx.inst(Inst::load_const(Operand::Reg(flags_reg as u32), flags_ci));
                 let r = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::CREATE_REGEXP, r, pat_reg, flags_reg));
+                ctx.inst(Inst::new(OpCode::CREATE_REGEXP, Operand::Reg(r as u32), Operand::Reg(pat_reg as u32), Operand::Reg(flags_reg as u32)));
                 Ok(r)
             } else {
                 Err(format!("unsupported regexp literal: {:?}", lit))

crates/oxide_compiler/src/expr/member/mod.rs

@@ -1,6 +1,8 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Expression;
 
 impl Compiler {
@@ -14,27 +16,24 @@ impl Compiler {
             let prop_name = member.property.name.as_str();
             let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
             let key_reg = ctx.alloc_reg();
-            ctx.emit_load_const(key_reg, idx);
+            ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
             let this_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, this_reg, 254, 0));
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(this_reg as u32), Operand::This, Operand::None));
             let result_reg = ctx.alloc_reg();
             let op = if ctx.in_static_method {
                 OpCode::SUPER_STATIC_GET_PROP
             } else {
                 OpCode::SUPER_GET_PROP
             };
-            ctx.emit(opcode::encode(op, result_reg, this_reg, key_reg));
+            ctx.inst(Inst::new(op, Operand::Reg(result_reg as u32), Operand::Reg(this_reg as u32), Operand::Reg(key_reg as u32)));
             return Ok(result_reg);
         }
         let obj_reg = self.emit_expression(&member.object, ctx)?;
         let prop_name = member.property.name.as_str();
         let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
         let key_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_CONST, key_reg, (idx & 0xFF) as u8, ((idx >> 8) & 0xFF) as u8));
-        ctx.emit(opcode::encode(OpCode::IC_GET_PROP, 0, obj_reg, key_reg));
-        ctx.emit(0);
-        ctx.emit(0);
-        ctx.emit(0);
+        ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
+        ctx.inst(Inst::ic_get(Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
         Ok(obj_reg)
     }
 
@@ -44,7 +43,7 @@ impl Compiler {
         let obj_reg = self.emit_expression(&member.object, ctx)?;
         let key_reg = self.emit_expression(&member.expression, ctx)?;
         let r = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::GET_PROP_DYNAMIC, obj_reg, key_reg, r));
+        ctx.inst(Inst::new(OpCode::GET_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(r as u32)));
         Ok(r)
     }
 
@@ -54,22 +53,21 @@ impl Compiler {
         let obj_reg = self.emit_expression(&member.object, ctx)?;
         let key_reg = self.emit_private_id_reg(member.field.name.as_str(), ctx)?;
         let r = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::GET_PRIVATE, r, obj_reg, key_reg));
+        ctx.inst(Inst::new(OpCode::GET_PRIVATE, Operand::Reg(r as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
         Ok(r)
     }
 
     fn emit_chain_expression(&self, chain: &oxide_parser::ChainExpression, ctx: &mut CompileCtx) -> Result<u8, String> {
-        let id = ctx.next_label_id();
-        let short_label = Label::TernaryElse(id);
-        let end_label = Label::TernaryEnd(id);
+        let short_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
         let value_reg = self.emit_chain_element(&chain.expression, Some(short_label), ctx)?;
         let result_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, value_reg, 0));
-        ctx.emit_jmp_labeled(end_label);
-        ctx.labels.label_map.insert(short_label, ctx.bytecode.len());
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(value_reg as u32), Operand::None));
+        ctx.inst(Inst::jmp(end_label));
+        ctx.labels.set_label_pos(short_label, ctx.insts.len());
         let undefined_idx = ctx.add_constant(Constant::Undefined);
-        ctx.emit_load_const(result_reg, undefined_idx);
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.inst(Inst::load_const(Operand::Reg(result_reg as u32), undefined_idx));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
         Ok(result_reg)
     }
 

crates/oxide_compiler/src/expr/object/array.rs

@@ -1,15 +1,15 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::{
-    module::Constant,
-    opcode::{self, OpCode},
-};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::module::Constant;
+use oxide_bytecode::opcode::OpCode;
 impl Compiler {
     pub(crate) fn emit_array_expression(
         &self, arr: &oxide_parser::ArrayExpression, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
         let arr_reg = ctx.alloc_reg();
         let n = arr.elements.len() as u16;
-        ctx.emit(opcode::encode(OpCode::NEW_ARRAY, arr_reg, (n & 0xFF) as u8, ((n >> 8) & 0xFF) as u8));
+        ctx.inst(Inst::new(OpCode::NEW_ARRAY, Operand::Reg(arr_reg as u32), Operand::Imm(n), Operand::None));
         let elem_checkpoint = ctx.reg_checkpoint();
         for (i, elem) in arr.elements.iter().enumerate() {
             let Some(e) = elem.as_expression() else {
@@ -18,8 +18,8 @@ impl Compiler {
             let val_reg = self.emit_expression(e, ctx)?;
             let idx_reg = ctx.alloc_reg();
             let idx = ctx.add_constant(Constant::Int(i as i32));
-            ctx.emit_load_const(idx_reg, idx);
-            ctx.emit(opcode::encode(OpCode::SET_ELEM, arr_reg, idx_reg, val_reg));
+            ctx.inst(Inst::load_const(Operand::Reg(idx_reg as u32), idx));
+            ctx.inst(Inst::new(OpCode::SET_ELEM, Operand::Reg(arr_reg as u32), Operand::Reg(idx_reg as u32), Operand::Reg(val_reg as u32)));
             ctx.restore_reg_checkpoint(elem_checkpoint);
         }
         Ok(arr_reg)

crates/oxide_compiler/src/expr/object/object_literal.rs

@@ -1,8 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::{
-    module::Constant,
-    opcode::{self, OpCode},
-};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::module::Constant;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{Expression, ObjectPropertyKind, PropertyKey, PropertyKind};
 
 impl Compiler {
@@ -10,7 +10,7 @@ impl Compiler {
         &self, obj: &oxide_parser::ObjectExpression, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
         let obj_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::NEW_OBJECT, obj_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::NEW_OBJECT, Operand::Reg(obj_reg as u32), Operand::None, Operand::None));
         let prop_checkpoint = ctx.reg_checkpoint();
         for prop in &obj.properties {
             let ObjectPropertyKind::ObjectProperty(p) = prop else {
@@ -24,7 +24,7 @@ impl Compiler {
             match p.kind {
                 PropertyKind::Get | PropertyKind::Set => {
                     let accessor_reg = self.emit_expression(&p.value, ctx)?;
-                    if let Some(sub_mod) = ctx.sub_modules.last_mut() {
+                    if let Some(sub_mod) = ctx.nested.last_mut() {
                         sub_mod.function_name = Some(prop_name.to_string());
                     }
                     let undef_reg = self.emit_undefined(ctx);
@@ -34,21 +34,25 @@ impl Compiler {
                         (undef_reg, accessor_reg)
                     };
                     let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
-                    ctx.emit(opcode::encode(OpCode::DEFINE_ACCESSOR, obj_reg, get_reg, set_reg));
-                    ctx.emit(idx as u32);
+                    ctx.inst(Inst::define_accessor(
+                        Operand::Reg(obj_reg as u32),
+                        Operand::Reg(get_reg as u32),
+                        Operand::Reg(set_reg as u32),
+                        idx as u32,
+                    ));
                     ctx.restore_reg_checkpoint(prop_checkpoint);
                 }
                 _ => {
                     let idx = ctx.add_constant(Constant::String(prop_name.to_string()));
                     let key_reg = ctx.alloc_reg();
-                    ctx.emit_load_const(key_reg, idx);
+                    ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
                     let val_reg = self.emit_expression(&p.value, ctx)?;
                     if matches!(&p.value, Expression::ArrowFunctionExpression(_)) {
-                        if let Some(sub_mod) = ctx.sub_modules.last_mut() {
+                        if let Some(sub_mod) = ctx.nested.last_mut() {
                             sub_mod.function_name = Some(prop_name.to_string());
                         }
                     }
-                    ctx.emit(opcode::encode(OpCode::SET_PROP, obj_reg, val_reg, key_reg));
+                    ctx.inst(Inst::new(OpCode::SET_PROP, Operand::Reg(obj_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(key_reg as u32)));
                     ctx.restore_reg_checkpoint(prop_checkpoint);
                 }
             }

crates/oxide_compiler/src/expr/operator/mod.rs

@@ -1,6 +1,8 @@
-use crate::compiler::{is_side_effect_free, BinaryOperator, CompileCtx, Compiler, Label};
+use crate::compiler::{is_side_effect_free, BinaryOperator, CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{ChainElement, Expression, LogicalOperator, SimpleAssignmentTarget, UnaryOperator, UpdateOperator};
 
 impl Compiler {
@@ -10,7 +12,7 @@ impl Compiler {
         let obj_reg = self.emit_expression(&pin.right, ctx)?;
         let key_reg = self.emit_private_id_reg(pin.left.name.as_str(), ctx)?;
         let result_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::PRIVATE_BRAND_IN, result_reg, obj_reg, key_reg));
+        ctx.inst(Inst::new(OpCode::PRIVATE_BRAND_IN, Operand::Reg(result_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
         Ok(result_reg)
     }
 
@@ -42,7 +44,7 @@ impl Compiler {
             BinaryOperator::StrictInequality => OpCode::STRICT_NEQ,
             _ => return Err(format!("unsupported binary operator: {:?}", bin.operator)),
         };
-        ctx.emit(opcode::encode(op, left, left, right));
+        ctx.inst(Inst::new(op, Operand::Reg(left as u32), Operand::Reg(left as u32), Operand::Reg(right as u32)));
         if is_side_effect_free(&bin.left) && is_side_effect_free(&bin.right) {
             ctx.restore_reg_checkpoint(checkpoint.saturating_add(1).max(left.saturating_add(1)));
         }
@@ -59,65 +61,49 @@ impl Compiler {
                     let obj_reg = self.emit_expression(&member.object, ctx)?;
                     let prop_name = member.property.name.as_str();
                     let const_idx = ctx.add_constant(Constant::String(prop_name.to_string()));
-                    ctx.emit(opcode::encode(OpCode::DELETE_PROP_STATIC, obj_reg, obj_reg, 0));
-                    ctx.emit(const_idx as u32);
+                    ctx.inst(Inst::delete_prop_static(Operand::Reg(obj_reg as u32), const_idx as u32));
                     Ok(obj_reg)
                 }
                 Expression::ComputedMemberExpression(member) => {
                     let obj_reg = self.emit_expression(&member.object, ctx)?;
                     let key_reg = self.emit_expression(&member.expression, ctx)?;
-                    ctx.emit(opcode::encode(OpCode::DELETE_PROP_DYNAMIC, obj_reg, obj_reg, key_reg));
+                    ctx.inst(Inst::new(OpCode::DELETE_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                     Ok(obj_reg)
                 }
                 Expression::ChainExpression(chain) => {
-                    let mut nullish_jumps = Vec::new();
+                    let short_label = ctx.next_label_id();
                     let result_reg = match &chain.expression {
                         ChainElement::StaticMemberExpression(member) => {
                             let obj_reg = self.emit_expression(&member.object, ctx)?;
                             if member.optional {
                                 let dup_reg = ctx.alloc_reg();
-                                ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, obj_reg, 0));
-                                let jump_pos = ctx.bytecode.len();
-                                ctx.emit(opcode::encode_jmp_if_nullish(dup_reg, 0));
-                                nullish_jumps.push(jump_pos);
+                                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(obj_reg as u32), Operand::None));
+                                ctx.inst(Inst::jmp_if_nullish(dup_reg, short_label));
                             }
                             let prop_name = member.property.name.as_str();
                             let const_idx = ctx.add_constant(Constant::String(prop_name.to_string()));
-                            ctx.emit(opcode::encode(OpCode::DELETE_PROP_STATIC, obj_reg, obj_reg, 0));
-                            ctx.emit(const_idx as u32);
+                            ctx.inst(Inst::delete_prop_static(Operand::Reg(obj_reg as u32), const_idx as u32));
                             obj_reg
                         }
                         ChainElement::ComputedMemberExpression(member) => {
                             let obj_reg = self.emit_expression(&member.object, ctx)?;
                             if member.optional {
                                 let dup_reg = ctx.alloc_reg();
-                                ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, obj_reg, 0));
-                                let jump_pos = ctx.bytecode.len();
-                                ctx.emit(opcode::encode_jmp_if_nullish(dup_reg, 0));
-                                nullish_jumps.push(jump_pos);
+                                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(obj_reg as u32), Operand::None));
+                                ctx.inst(Inst::jmp_if_nullish(dup_reg, short_label));
                             }
                             let key_reg = self.emit_expression(&member.expression, ctx)?;
-                            ctx.emit(opcode::encode(OpCode::DELETE_PROP_DYNAMIC, obj_reg, obj_reg, key_reg));
+                            ctx.inst(Inst::new(OpCode::DELETE_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                             obj_reg
                         }
                         _ => return Err("invalid delete target".into()),
                     };
-                    let end_jump_pos = ctx.bytecode.len();
-                    ctx.emit(opcode::encode_jmp(0));
-                    let short_pos = ctx.bytecode.len();
-                    for jump_pos in nullish_jumps {
-                        let offset = (short_pos as isize) - (jump_pos as isize);
-                        let instr = ctx.bytecode[jump_pos];
-                        let rd = opcode::rd(instr);
-                        let offset = ctx.checked_jump_offset(offset);
-                        ctx.bytecode[jump_pos] = opcode::encode_jmp_if_nullish(rd, offset);
-                    }
+                    let end_label = ctx.next_label_id();
+                    ctx.inst(Inst::jmp(end_label));
+                    ctx.labels.set_label_pos(short_label, ctx.insts.len());
                     let true_idx = ctx.add_constant(Constant::Boolean(true));
-                    ctx.emit_load_const(result_reg, true_idx);
-                    let end_pos = ctx.bytecode.len();
-                    let offset = (end_pos as isize) - (end_jump_pos as isize);
-                    let offset = ctx.checked_jump_offset(offset);
-                    ctx.bytecode[end_jump_pos] = opcode::encode_jmp(offset);
+                    ctx.inst(Inst::load_const(Operand::Reg(result_reg as u32), true_idx));
+                    ctx.labels.set_label_pos(end_label, ctx.insts.len());
                     Ok(result_reg)
                 }
                 _ => Err("invalid delete target".into()),
@@ -126,27 +112,27 @@ impl Compiler {
         let arg = self.emit_expression(&un.argument, ctx)?;
         match un.operator {
             UnaryOperator::UnaryNegation => {
-                ctx.emit(opcode::encode(OpCode::NEG, arg, arg, 0));
+                ctx.inst(Inst::new(OpCode::NEG, Operand::Reg(arg as u32), Operand::Reg(arg as u32), Operand::None));
                 Ok(arg)
             }
             UnaryOperator::Typeof => {
-                ctx.emit(opcode::encode(OpCode::TYPEOF, arg, arg, 0));
+                ctx.inst(Inst::new(OpCode::TYPEOF, Operand::Reg(arg as u32), Operand::Reg(arg as u32), Operand::None));
                 Ok(arg)
             }
             UnaryOperator::Void => {
-                ctx.emit(opcode::encode(OpCode::VOID, arg, arg, 0));
+                ctx.inst(Inst::new(OpCode::VOID, Operand::Reg(arg as u32), Operand::Reg(arg as u32), Operand::None));
                 Ok(arg)
             }
             UnaryOperator::LogicalNot => {
-                ctx.emit(opcode::encode(OpCode::NOT, arg, arg, 0));
+                ctx.inst(Inst::new(OpCode::NOT, Operand::Reg(arg as u32), Operand::Reg(arg as u32), Operand::None));
                 Ok(arg)
             }
             UnaryOperator::BitwiseNot => {
-                ctx.emit(opcode::encode(OpCode::BIT_NOT, arg, arg, 0));
+                ctx.inst(Inst::new(OpCode::BIT_NOT, Operand::Reg(arg as u32), Operand::Reg(arg as u32), Operand::None));
                 Ok(arg)
             }
             UnaryOperator::UnaryPlus => {
-                ctx.emit(opcode::encode(OpCode::UNARY_PLUS, arg, arg, 0));
+                ctx.inst(Inst::new(OpCode::UNARY_PLUS, Operand::Reg(arg as u32), Operand::Reg(arg as u32), Operand::None));
                 Ok(arg)
             }
             UnaryOperator::Delete => Err("invalid delete target".into()),
@@ -156,23 +142,22 @@ impl Compiler {
     fn emit_conditional_expression(
         &self, cond: &oxide_parser::ConditionalExpression, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
-        let id = ctx.next_label_id();
-        let else_label = Label::TernaryElse(id);
-        let end_label = Label::TernaryEnd(id);
+        let else_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
 
         let test_reg = self.emit_expression(&cond.test, ctx)?;
-        ctx.emit_jmp_if_false_labeled(test_reg, else_label);
+        ctx.inst(Inst::jmp_if_false(test_reg, else_label));
 
         let cons_reg = self.emit_expression(&cond.consequent, ctx)?;
         let result_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, cons_reg, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(cons_reg as u32), Operand::None));
 
-        ctx.emit_jmp_labeled(end_label);
+        ctx.inst(Inst::jmp(end_label));
 
-        ctx.labels.label_map.insert(else_label, ctx.bytecode.len());
+        ctx.labels.set_label_pos(else_label, ctx.insts.len());
         let alt_reg = self.emit_expression(&cond.alternate, ctx)?;
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, alt_reg, 0));
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(alt_reg as u32), Operand::None));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
 
         Ok(result_reg)
     }
@@ -190,43 +175,41 @@ impl Compiler {
                 LogicalOperator::Or => OpCode::OR,
                 LogicalOperator::Coalesce => OpCode::NULLISH,
             };
-            ctx.emit(opcode::encode(op, r, left_reg, right_reg));
+            ctx.inst(Inst::new(op, Operand::Reg(r as u32), Operand::Reg(left_reg as u32), Operand::Reg(right_reg as u32)));
             return Ok(r);
         }
 
         if matches!(log.operator, LogicalOperator::Coalesce) {
-            let id = ctx.next_label_id();
-            let rhs_label = Label::TernaryElse(id);
-            let end_label = Label::TernaryEnd(id);
+            let rhs_label = ctx.next_label_id();
+            let end_label = ctx.next_label_id();
             let dup_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, left_reg, 0));
-            ctx.emit_jmp_if_nullish_labeled(dup_reg, rhs_label);
-            ctx.emit_jmp_labeled(end_label);
-            ctx.labels.label_map.insert(rhs_label, ctx.bytecode.len());
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(left_reg as u32), Operand::None));
+            ctx.inst(Inst::jmp_if_nullish(dup_reg, rhs_label));
+            ctx.inst(Inst::jmp(end_label));
+            ctx.labels.set_label_pos(rhs_label, ctx.insts.len());
             let right_reg = self.emit_expression(&log.right, ctx)?;
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, right_reg, 0));
-            ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(right_reg as u32), Operand::None));
+            ctx.labels.set_label_pos(end_label, ctx.insts.len());
             return Ok(dup_reg);
         }
 
-        let id = ctx.next_label_id();
         let skip_label = match log.operator {
-            LogicalOperator::And => Label::TernaryEnd(id),
-            LogicalOperator::Or => Label::TernaryElse(id),
+            LogicalOperator::And => ctx.next_label_id(),
+            LogicalOperator::Or => ctx.next_label_id(),
             LogicalOperator::Coalesce => return Err("invalid logical operator dispatch".into()),
         };
         let dup_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, left_reg, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(left_reg as u32), Operand::None));
 
         match log.operator {
-            LogicalOperator::And => ctx.emit_jmp_if_false_labeled(dup_reg, skip_label),
-            LogicalOperator::Or => ctx.emit_jmp_if_true_labeled(dup_reg, skip_label),
+            LogicalOperator::And => ctx.inst(Inst::jmp_if_false(dup_reg, skip_label)),
+            LogicalOperator::Or => ctx.inst(Inst::jmp_if_true(dup_reg, skip_label)),
             LogicalOperator::Coalesce => return Err("invalid logical operator dispatch".into()),
         }
 
         let right_reg = self.emit_expression(&log.right, ctx)?;
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, right_reg, 0));
-        ctx.labels.label_map.insert(skip_label, ctx.bytecode.len());
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(right_reg as u32), Operand::None));
+        ctx.labels.set_label_pos(skip_label, ctx.insts.len());
 
         Ok(dup_reg)
     }
@@ -243,17 +226,17 @@ impl Compiler {
                 if let Some(uv) = uv_idx {
                     // Upvalue: LOAD_UPVALUE + CONST(1) + ADD/SUB + STORE_UPVALUE
                     let val_reg = ctx.alloc_reg();
-                    ctx.emit(opcode::encode(OpCode::LOAD_UPVALUE, val_reg, uv as u8, 0));
+                    ctx.inst(Inst::new(OpCode::LOAD_UPVALUE, Operand::Reg(val_reg as u32), Operand::Imm(uv as u16), Operand::None));
                     let one_idx = ctx.add_constant(Constant::Int(1));
                     let one_reg = ctx.alloc_reg();
-                    ctx.emit_load_const(one_reg, one_idx);
+                    ctx.inst(Inst::load_const(Operand::Reg(one_reg as u32), one_idx));
                     let op = if update.operator == UpdateOperator::Increment {
                         OpCode::ADD
                     } else {
                         OpCode::SUB
                     };
-                    ctx.emit(opcode::encode(op, val_reg, val_reg, one_reg));
-                    ctx.emit(opcode::encode(OpCode::STORE_UPVALUE, 0, val_reg, uv as u8));
+                    ctx.inst(Inst::new(op, Operand::Reg(val_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(one_reg as u32)));
+                    ctx.inst(Inst::new(OpCode::STORE_UPVALUE, Operand::None, Operand::Reg(val_reg as u32), Operand::Imm(uv as u16)));
                     Ok(val_reg)
                 } else if is_captured {
                     // Captured cell: CELL_GET + CONST(1) + ADD/SUB + CELL_SET
@@ -266,20 +249,20 @@ impl Compiler {
                         .unwrap_or(0);
                     let val_reg = ctx.alloc_reg();
                     if let Some((binding, _)) = ctx.scopes.symbols.lookup_any_binding(name) {
-                        ctx.emit(opcode::encode(OpCode::CELL_GET, val_reg, binding.reg, cell_idx));
+                        ctx.inst(Inst::new(OpCode::CELL_GET, Operand::Reg(val_reg as u32), Operand::Reg(binding.reg as u32), Operand::Imm(cell_idx as u16)));
                     } else {
-                        ctx.emit(opcode::encode(OpCode::CELL_GET, val_reg, 0, cell_idx));
+                        ctx.inst(Inst::new(OpCode::CELL_GET, Operand::Reg(val_reg as u32), Operand::None, Operand::Imm(cell_idx as u16)));
                     }
                     let one_idx = ctx.add_constant(Constant::Int(1));
                     let one_reg = ctx.alloc_reg();
-                    ctx.emit_load_const(one_reg, one_idx);
+                    ctx.inst(Inst::load_const(Operand::Reg(one_reg as u32), one_idx));
                     let op = if update.operator == UpdateOperator::Increment {
                         OpCode::ADD
                     } else {
                         OpCode::SUB
                     };
-                    ctx.emit(opcode::encode(op, val_reg, val_reg, one_reg));
-                    ctx.emit(opcode::encode(OpCode::CELL_SET, 0, val_reg, cell_idx));
+                    ctx.inst(Inst::new(op, Operand::Reg(val_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(one_reg as u32)));
+                    ctx.inst(Inst::new(OpCode::CELL_SET, Operand::None, Operand::Reg(val_reg as u32), Operand::Imm(cell_idx as u16)));
                     Ok(val_reg)
                 } else {
                     let var_reg = ctx.lookup_or_global(name);
@@ -290,7 +273,7 @@ impl Compiler {
                         (UpdateOperator::Decrement, true) => OpCode::DEC_PRE,
                         (UpdateOperator::Decrement, false) => OpCode::DEC_POST,
                     };
-                    ctx.emit(opcode::encode(op, var_reg, result_reg, result_reg));
+                    ctx.inst(Inst::new(op, Operand::Reg(var_reg as u32), Operand::Reg(result_reg as u32), Operand::Reg(result_reg as u32)));
                     Ok(result_reg)
                 }
             }
@@ -299,21 +282,21 @@ impl Compiler {
                 let prop_name = member.property.name.as_str();
                 let key_idx = ctx.add_constant(Constant::String(prop_name.to_string()));
                 let key_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(
-                    OpCode::LOAD_CONST,
-                    key_reg,
-                    (key_idx & 0xFF) as u8,
-                    ((key_idx >> 8) & 0xFF) as u8,
-                ));
+                ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), key_idx));
                 let val_reg = ctx.alloc_reg();
                 let op = match update.operator {
                     UpdateOperator::Increment => OpCode::MEMBER_INC,
                     UpdateOperator::Decrement => OpCode::MEMBER_DEC,
                 };
-                ctx.emit(opcode::encode(op, obj_reg, val_reg, key_reg));
-                ctx.emit(0);
-                ctx.emit(0);
-                ctx.emit(0);
+                match op {
+                    OpCode::MEMBER_INC => {
+                        ctx.inst(Inst::member_inc(Operand::Reg(obj_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(key_reg as u32)));
+                    }
+                    OpCode::MEMBER_DEC => {
+                        ctx.inst(Inst::member_dec(Operand::Reg(obj_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(key_reg as u32)));
+                    }
+                    _ => unreachable!(),
+                }
                 Ok(val_reg)
             }
             SimpleAssignmentTarget::ComputedMemberExpression(member) => {
@@ -324,7 +307,7 @@ impl Compiler {
                     UpdateOperator::Increment => OpCode::DYN_MEMBER_INC,
                     UpdateOperator::Decrement => OpCode::DYN_MEMBER_DEC,
                 };
-                ctx.emit(opcode::encode(op, obj_reg, key_reg, val_reg));
+                ctx.inst(Inst::new(op, Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(val_reg as u32)));
                 Ok(val_reg)
             }
             _ => Err("member update not yet supported".into()),

crates/oxide_compiler/src/expr/template/tagged.rs

@@ -1,8 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::{
-    module::Constant,
-    opcode::{self, OpCode},
-};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::module::Constant;
+use oxide_bytecode::opcode::OpCode;
 impl Compiler {
     pub(crate) fn emit_tagged_template_expression(
         &self, tt: &oxide_parser::TaggedTemplateExpression, ctx: &mut CompileCtx,
@@ -13,29 +13,29 @@ impl Compiler {
         let tag_reg = self.emit_expression(&tt.tag, ctx)?;
 
         let cooked_temp = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::NEW_ARRAY, cooked_temp, quasis.len() as u8, 0));
+        ctx.inst(Inst::new(OpCode::NEW_ARRAY, Operand::Reg(cooked_temp as u32), Operand::Imm(quasis.len() as u16), Operand::None));
         for (i, quasi) in quasis.iter().enumerate() {
             let s = quasi.value.cooked.as_ref().map(|c| c.to_string()).unwrap_or_default();
             let const_idx = ctx.add_constant(Constant::String(s));
             let str_reg = ctx.alloc_reg();
-            ctx.emit_load_const(str_reg, const_idx);
+            ctx.inst(Inst::load_const(Operand::Reg(str_reg as u32), const_idx));
             let idx_const = ctx.add_constant(Constant::Int(i as i32));
             let idx_reg = ctx.alloc_reg();
-            ctx.emit_load_const(idx_reg, idx_const);
-            ctx.emit(opcode::encode(OpCode::SET_ELEM, cooked_temp, idx_reg, str_reg));
+            ctx.inst(Inst::load_const(Operand::Reg(idx_reg as u32), idx_const));
+            ctx.inst(Inst::new(OpCode::SET_ELEM, Operand::Reg(cooked_temp as u32), Operand::Reg(idx_reg as u32), Operand::Reg(str_reg as u32)));
         }
 
         let raw_temp = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::NEW_ARRAY, raw_temp, quasis.len() as u8, 0));
+        ctx.inst(Inst::new(OpCode::NEW_ARRAY, Operand::Reg(raw_temp as u32), Operand::Imm(quasis.len() as u16), Operand::None));
         for (i, quasi) in quasis.iter().enumerate() {
             let raw = quasi.value.raw.to_string();
             let const_idx = ctx.add_constant(Constant::String(raw));
             let str_reg = ctx.alloc_reg();
-            ctx.emit_load_const(str_reg, const_idx);
+            ctx.inst(Inst::load_const(Operand::Reg(str_reg as u32), const_idx));
             let idx_const = ctx.add_constant(Constant::Int(i as i32));
             let idx_reg = ctx.alloc_reg();
-            ctx.emit_load_const(idx_reg, idx_const);
-            ctx.emit(opcode::encode(OpCode::SET_ELEM, raw_temp, idx_reg, str_reg));
+            ctx.inst(Inst::load_const(Operand::Reg(idx_reg as u32), idx_const));
+            ctx.inst(Inst::new(OpCode::SET_ELEM, Operand::Reg(raw_temp as u32), Operand::Reg(idx_reg as u32), Operand::Reg(str_reg as u32)));
         }
 
         let mut expr_temps = Vec::new();
@@ -50,22 +50,26 @@ impl Compiler {
             expr_slots.push(ctx.alloc_reg());
         }
 
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, cooked_slot, cooked_temp, 0));
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, raw_slot, raw_temp, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(cooked_slot as u32), Operand::Reg(cooked_temp as u32), Operand::None));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(raw_slot as u32), Operand::Reg(raw_temp as u32), Operand::None));
         for (slot, temp) in expr_slots.iter().zip(expr_temps.iter()) {
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, *slot, *temp, 0));
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(*slot as u32), Operand::Reg(*temp as u32), Operand::None));
         }
 
         let undef_idx = ctx.add_constant(Constant::Undefined);
         let undef_reg = ctx.alloc_reg();
-        ctx.emit_load_const(undef_reg, undef_idx);
+        ctx.inst(Inst::load_const(Operand::Reg(undef_reg as u32), undef_idx));
 
         let arg_count = 2 + expressions.len();
-        ctx.emit(opcode::encode(OpCode::CALL, tag_reg, undef_reg, cooked_slot));
-        ctx.emit(arg_count as u32);
+        ctx.inst(Inst::call(
+            Operand::Reg(tag_reg as u32),
+            Operand::Reg(undef_reg as u32),
+            Operand::Reg(cooked_slot as u32),
+            arg_count as u8,
+        ));
 
         let result_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::None, Operand::None));
         Ok(result_reg)
     }
 }

crates/oxide_compiler/src/expr/template/template_literal.rs

@@ -1,8 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::{
-    module::Constant,
-    opcode::{self, OpCode},
-};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::module::Constant;
+
 impl Compiler {
     pub(crate) fn emit_template_literal_expression(
         &self, tl: &oxide_parser::TemplateLiteral, ctx: &mut CompileCtx,
@@ -30,17 +30,22 @@ impl Compiler {
             .map(|q| q.value.cooked.as_ref().map(|c| c.len()).unwrap_or(0))
             .sum();
 
-        ctx.emit(opcode::encode(OpCode::TEMPLATE_STR, r, 0, 0));
-        ctx.emit(((segment_count as u32) << 16) | (total_len_hint as u32 & 0xFFFF));
-
+        let mut parts = Vec::with_capacity(quasi_const_idxs.len() * 2);
         let mut expr_iter = expr_regs.iter();
         for const_idx in quasi_const_idxs.iter() {
-            ctx.emit(*const_idx as u32 & 0x7FFF_FFFF);
+            parts.push(*const_idx as u32 & 0x7FFF_FFFF);
             if let Some(expr_reg) = expr_iter.next() {
-                ctx.emit(0x8000_0000u32 | (*expr_reg as u32));
+                parts.push(0x8000_0000u32 | (*expr_reg as u32));
             }
         }
 
+        ctx.inst(Inst::template_str(
+            Operand::Reg(r as u32),
+            segment_count as u32,
+            total_len_hint as u16,
+            &parts,
+        ));
+
         Ok(r)
     }
 }

crates/oxide_compiler/src/expr/this.rs

@@ -1,11 +1,14 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 
 impl Compiler {
     pub(crate) fn emit_this_expression(&self, ctx: &mut CompileCtx) -> Result<u8, String> {
         let r = ctx.alloc_reg();
         let src = ctx.static_block_this_reg.unwrap_or(254);
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, r, src, 0));
+        let src_op = if src == 254 { Operand::This } else { Operand::Reg(src as u32) };
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(r as u32), src_op, Operand::None));
         Ok(r)
     }
 }

crates/oxide_compiler/src/ir/inst.rs

@@ -105,10 +105,29 @@ impl Inst {
         Self::with_ext(OpCode::DEFINE_ACCESSOR, home, get, set, &[key_idx])
     }
 
+    pub fn delete_prop_static(obj: Operand, const_idx: u32) -> Self {
+        Self::with_ext(OpCode::DELETE_PROP_STATIC, obj, obj, Operand::None, &[const_idx])
+    }
+
     pub fn rest_object(rest: Operand, src: Operand, excluded_idx: u32) -> Self {
         Self::with_ext(OpCode::REST_OBJECT, rest, src, Operand::None, &[excluded_idx])
     }
 
+    /// TEMPLATE_STR：变长 ext。首字打包 `(segment_count<<16) | total_len_hint`，
+    /// 后续每 quasi 一项 `quasi_const_idx & 0x7FFF_FFFF`，其后若跟表达式再一项 `0x8000_0000 | expr_reg`。
+    pub fn template_str(dst: Operand, segment_count: u32, total_len_hint: u16, parts: &[u32]) -> Self {
+        let mut ext = SmallVec::with_capacity(2 + parts.len());
+        ext.push(((segment_count & 0xFFFF) << 16) | (total_len_hint as u32 & 0xFFFF));
+        ext.extend_from_slice(parts);
+        Self {
+            op: OpCode::TEMPLATE_STR,
+            rd: dst,
+            a: Operand::None,
+            b: Operand::None,
+            ext,
+        }
+    }
+
     // ── 无 ext：立即数/索引指令（拆字是 lowering 职责）──
 
     pub fn load_const(dst: Operand, idx: u16) -> Self {
@@ -262,4 +281,15 @@ mod tests {
         let try_fin = Inst::try_finally_begin(9);
         assert_eq!(try_fin.b, Operand::Label(9));
     }
+
+    #[test]
+    fn template_str_packs_segment_count_and_hint() {
+        let inst = Inst::template_str(Operand::Reg(1), 3, 10, &[0x1234, 0x8000_0000 | 5]);
+        assert_eq!(inst.op, OpCode::TEMPLATE_STR);
+        assert_eq!(inst.rd, Operand::Reg(1));
+        assert_eq!(inst.ext.len(), 3);
+        assert_eq!(inst.ext[0], (3 << 16) | 10);
+        assert_eq!(inst.ext[1], 0x1234);
+        assert_eq!(inst.ext[2], 0x8000_0000 | 5);
+    }
 }

crates/oxide_compiler/src/shared/binding.rs

@@ -1,6 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{
     ArrayAssignmentTarget, ArrayPattern, AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty,
     BindingPattern, Expression, ObjectAssignmentTarget, ObjectPattern, VariableDeclarationKind,
@@ -12,15 +14,13 @@ impl Compiler {
     ) -> Result<u8, String> {
         let undef_reg = self.emit_undefined(ctx);
         let eq_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::STRICT_EQ, eq_reg, val_reg, undef_reg));
-        let jump_pos = ctx.bytecode.len();
-        ctx.emit(opcode::encode_jmp_if_false(eq_reg, 0));
+        ctx.inst(Inst::new(OpCode::STRICT_EQ, Operand::Reg(eq_reg as u32), Operand::Reg(val_reg as u32), Operand::Reg(undef_reg as u32)));
+        // val != undefined（eq 为 false）→ 跳过默认值
+        let end_label = ctx.next_label_id();
+        ctx.inst(Inst::jmp_if_false(eq_reg, end_label));
         let default_reg = self.emit_expression(default_expr, ctx)?;
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, val_reg, default_reg, 0));
-        let after = ctx.bytecode.len();
-        let offset = after as isize - jump_pos as isize;
-        let offset = ctx.checked_jump_offset(offset);
-        ctx.bytecode[jump_pos] = opcode::encode_jmp_if_false(eq_reg, offset);
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(val_reg as u32), Operand::Reg(default_reg as u32), Operand::None));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
         Ok(val_reg)
     }
 
@@ -45,9 +45,9 @@ impl Compiler {
         if ctx.scopes.symbols.lookup_is_captured(name) {
             let cell_idx = ctx.scopes.cell_registry.len() as u8;
             ctx.scopes.cell_registry.push((name.to_string(), cell_idx));
-            ctx.emit(opcode::encode(OpCode::MAKE_CELL, src_reg, cell_idx, 0));
+            ctx.inst(Inst::new(OpCode::MAKE_CELL, Operand::Reg(src_reg as u32), Operand::Imm(cell_idx as u16), Operand::None));
         } else {
-            ctx.emit(opcode::encode(OpCode::STORE_VAR, target_reg, src_reg, if is_const { 1 } else { 0 }));
+            ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(target_reg as u32), Operand::Reg(src_reg as u32), Operand::Imm(if is_const { 1 } else { 0 })));
         }
         ctx.init_var(name);
         Ok(())
@@ -60,11 +60,11 @@ impl Compiler {
             AssignmentTarget::AssignmentTargetIdentifier(id) => {
                 let name = id.name.as_str();
                 let var_reg = ctx.lookup_or_global(name);
-                ctx.emit(opcode::encode(
+                ctx.inst(Inst::new(
                     OpCode::STORE_VAR,
-                    var_reg,
-                    src_reg,
-                    if ctx.lookup_const_flag(name) { 1 } else { 0 },
+                    Operand::Reg(var_reg as u32),
+                    Operand::Reg(src_reg as u32),
+                    Operand::Imm(if ctx.lookup_const_flag(name) { 1 } else { 0 }),
                 ));
                 Ok(())
             }
@@ -94,12 +94,12 @@ impl Compiler {
     fn emit_array_binding(
         &self, ap: &ArrayPattern, src_reg: u8, kind: VariableDeclarationKind, is_const: bool, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
-        ctx.emit(opcode::encode(OpCode::FOR_OF_INIT, 0, src_reg, 0));
+        ctx.inst(Inst::new(OpCode::FOR_OF_INIT, Operand::None, Operand::Reg(src_reg as u32), Operand::None));
         for elem in &ap.elements {
             let has_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::FOR_OF_DONE, has_reg, 0, 0));
+            ctx.inst(Inst::new(OpCode::FOR_OF_DONE, Operand::Reg(has_reg as u32), Operand::None, Operand::None));
             let val_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::FOR_OF_NEXT, val_reg, 0, 0));
+            ctx.inst(Inst::new(OpCode::FOR_OF_NEXT, Operand::Reg(val_reg as u32), Operand::None, Operand::None));
             if let Some(pattern) = elem {
                 self.emit_binding_pattern(pattern, val_reg, kind, is_const, ctx)?;
             }
@@ -108,33 +108,29 @@ impl Compiler {
             let rest_reg = self.emit_collect_rest_array(ctx)?;
             self.emit_binding_pattern(&rest.argument, rest_reg, kind, is_const, ctx)?;
         }
-        ctx.emit(opcode::encode(OpCode::FOR_OF_CLOSE, 0, 0, 0));
+        ctx.inst(Inst::new(OpCode::FOR_OF_CLOSE, Operand::None, Operand::None, Operand::None));
         Ok(())
     }
 
     fn emit_collect_rest_array(&self, ctx: &mut CompileCtx) -> Result<u8, String> {
         let rest_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::NEW_ARRAY, rest_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::NEW_ARRAY, Operand::Reg(rest_reg as u32), Operand::None, Operand::None));
         let idx_reg = ctx.alloc_reg();
         let zero_idx = ctx.add_constant(Constant::Int(0));
-        ctx.emit_load_const(idx_reg, zero_idx);
-        let loop_start = ctx.bytecode.len();
+        ctx.inst(Inst::load_const(Operand::Reg(idx_reg as u32), zero_idx));
+        let loop_start = ctx.next_label_id();
+        let loop_end = ctx.next_label_id();
+        ctx.labels.set_label_pos(loop_start, ctx.insts.len());
         let has_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::FOR_OF_DONE, has_reg, 0, 0));
-        let end_jmp = ctx.bytecode.len();
-        ctx.emit(opcode::encode_jmp_if_false(has_reg, 0));
+        ctx.inst(Inst::new(OpCode::FOR_OF_DONE, Operand::Reg(has_reg as u32), Operand::None, Operand::None));
+        ctx.inst(Inst::jmp_if_false(has_reg, loop_end));
         let val_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::FOR_OF_NEXT, val_reg, 0, 0));
-        ctx.emit(opcode::encode(OpCode::SET_ELEM, rest_reg, idx_reg, val_reg));
+        ctx.inst(Inst::new(OpCode::FOR_OF_NEXT, Operand::Reg(val_reg as u32), Operand::None, Operand::None));
+        ctx.inst(Inst::new(OpCode::SET_ELEM, Operand::Reg(rest_reg as u32), Operand::Reg(idx_reg as u32), Operand::Reg(val_reg as u32)));
         let tmp_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::INC_PRE, idx_reg, tmp_reg, tmp_reg));
-        let back = loop_start as isize - ctx.bytecode.len() as isize;
-        let back = ctx.checked_jump_offset(back);
-        ctx.emit(opcode::encode_jmp(back));
-        let after = ctx.bytecode.len();
-        let end_offset = after as isize - end_jmp as isize;
-        let end_offset = ctx.checked_jump_offset(end_offset);
-        ctx.bytecode[end_jmp] = opcode::encode_jmp_if_false(has_reg, end_offset);
+        ctx.inst(Inst::new(OpCode::INC_PRE, Operand::Reg(idx_reg as u32), Operand::Reg(tmp_reg as u32), Operand::Reg(tmp_reg as u32)));
+        ctx.inst(Inst::jmp(loop_start));
+        ctx.labels.set_label_pos(loop_end, ctx.insts.len());
         Ok(rest_reg)
     }
 
@@ -152,8 +148,7 @@ impl Compiler {
         if let Some(rest) = &op.rest {
             let rest_reg = ctx.alloc_reg();
             let excluded_idx = ctx.add_constant(Constant::String(excluded.join("\0")));
-            ctx.emit(opcode::encode(OpCode::REST_OBJECT, rest_reg, src_reg, 0));
-            ctx.emit(excluded_idx as u32);
+            ctx.inst(Inst::rest_object(Operand::Reg(rest_reg as u32), Operand::Reg(src_reg as u32), excluded_idx as u32));
             self.emit_binding_pattern(&rest.argument, rest_reg, kind, is_const, ctx)?;
         }
         Ok(())
@@ -172,11 +167,11 @@ impl Compiler {
             AssignmentTargetMaybeDefault::AssignmentTargetIdentifier(id) => {
                 let name = id.name.as_str();
                 let var_reg = ctx.lookup_or_global(name);
-                ctx.emit(opcode::encode(
+                ctx.inst(Inst::new(
                     OpCode::STORE_VAR,
-                    var_reg,
-                    src_reg,
-                    if ctx.lookup_const_flag(name) { 1 } else { 0 },
+                    Operand::Reg(var_reg as u32),
+                    Operand::Reg(src_reg as u32),
+                    Operand::Imm(if ctx.lookup_const_flag(name) { 1 } else { 0 }),
                 ));
                 Ok(())
             }
@@ -187,12 +182,12 @@ impl Compiler {
     pub(crate) fn emit_array_assignment(
         &self, ap: &ArrayAssignmentTarget, src_reg: u8, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
-        ctx.emit(opcode::encode(OpCode::FOR_OF_INIT, 0, src_reg, 0));
+        ctx.inst(Inst::new(OpCode::FOR_OF_INIT, Operand::None, Operand::Reg(src_reg as u32), Operand::None));
         for elem in &ap.elements {
             let has_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::FOR_OF_DONE, has_reg, 0, 0));
+            ctx.inst(Inst::new(OpCode::FOR_OF_DONE, Operand::Reg(has_reg as u32), Operand::None, Operand::None));
             let val_reg = ctx.alloc_reg();
-            ctx.emit(opcode::encode(OpCode::FOR_OF_NEXT, val_reg, 0, 0));
+            ctx.inst(Inst::new(OpCode::FOR_OF_NEXT, Operand::Reg(val_reg as u32), Operand::None, Operand::None));
             if let Some(target) = elem {
                 self.emit_assignment_maybe_default(target, val_reg, ctx)?;
             }
@@ -201,7 +196,7 @@ impl Compiler {
             let rest_reg = self.emit_collect_rest_array(ctx)?;
             self.emit_assign_target(&rest.target, rest_reg, ctx)?;
         }
-        ctx.emit(opcode::encode(OpCode::FOR_OF_CLOSE, 0, 0, 0));
+        ctx.inst(Inst::new(OpCode::FOR_OF_CLOSE, Operand::None, Operand::None, Operand::None));
         Ok(())
     }
 
@@ -220,11 +215,11 @@ impl Compiler {
                     }
                     let name = id.binding.name.as_str();
                     let var_reg = ctx.lookup_or_global(name);
-                    ctx.emit(opcode::encode(
+                    ctx.inst(Inst::new(
                         OpCode::STORE_VAR,
-                        var_reg,
-                        prop_reg,
-                        if ctx.lookup_const_flag(name) { 1 } else { 0 },
+                        Operand::Reg(var_reg as u32),
+                        Operand::Reg(prop_reg as u32),
+                        Operand::Imm(if ctx.lookup_const_flag(name) { 1 } else { 0 }),
                     ));
                 }
                 AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => {
@@ -240,8 +235,7 @@ impl Compiler {
         if let Some(rest) = &op.rest {
             let rest_reg = ctx.alloc_reg();
             let excluded_idx = ctx.add_constant(Constant::String(excluded.join("\0")));
-            ctx.emit(opcode::encode(OpCode::REST_OBJECT, rest_reg, src_reg, 0));
-            ctx.emit(excluded_idx as u32);
+            ctx.inst(Inst::rest_object(Operand::Reg(rest_reg as u32), Operand::Reg(src_reg as u32), excluded_idx as u32));
             self.emit_assign_target(&rest.target, rest_reg, ctx)?;
         }
         Ok(())

crates/oxide_compiler/src/shared/chain.rs

@@ -1,18 +1,20 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::{LabelId, Operand};
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{ChainElement, Expression, LogicalOperator, PropertyKey};
 
 impl Compiler {
-    fn emit_optional_guard(&self, reg: u8, short_label: Label, ctx: &mut CompileCtx) -> Result<(), String> {
+    fn emit_optional_guard(&self, reg: u8, short_label: LabelId, ctx: &mut CompileCtx) -> Result<(), String> {
         let dup_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, dup_reg, reg, 0));
-        ctx.emit_jmp_if_nullish_labeled(dup_reg, short_label);
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(dup_reg as u32), Operand::Reg(reg as u32), Operand::None));
+        ctx.inst(Inst::jmp_if_nullish(dup_reg, short_label));
         Ok(())
     }
 
     fn emit_static_member_get_preserve_base(
-        &self, member: &oxide_parser::StaticMemberExpression, short_label: Option<Label>, ctx: &mut CompileCtx,
+        &self, member: &oxide_parser::StaticMemberExpression, short_label: Option<LabelId>, ctx: &mut CompileCtx,
     ) -> Result<(u8, u8), String> {
         let obj_reg = self.emit_chainable_expression(&member.object, short_label, ctx)?;
         if member.optional {
@@ -22,18 +24,15 @@ impl Compiler {
         }
         let idx = ctx.add_constant(Constant::String(member.property.name.as_str().to_string()));
         let key_reg = ctx.alloc_reg();
-        ctx.emit_load_const(key_reg, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), idx));
         let value_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, value_reg, obj_reg, 0));
-        ctx.emit(opcode::encode(OpCode::IC_GET_PROP, 0, value_reg, key_reg));
-        ctx.emit(0);
-        ctx.emit(0);
-        ctx.emit(0);
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(value_reg as u32), Operand::Reg(obj_reg as u32), Operand::None));
+        ctx.inst(Inst::ic_get(Operand::Reg(value_reg as u32), Operand::Reg(key_reg as u32)));
         Ok((value_reg, obj_reg))
     }
 
     fn emit_computed_member_get_preserve_base(
-        &self, member: &oxide_parser::ComputedMemberExpression, short_label: Option<Label>, ctx: &mut CompileCtx,
+        &self, member: &oxide_parser::ComputedMemberExpression, short_label: Option<LabelId>, ctx: &mut CompileCtx,
     ) -> Result<(u8, u8), String> {
         let obj_reg = self.emit_chainable_expression(&member.object, short_label, ctx)?;
         if member.optional {
@@ -43,12 +42,12 @@ impl Compiler {
         }
         let key_reg = self.emit_expression(&member.expression, ctx)?;
         let value_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::GET_PROP_DYNAMIC, obj_reg, key_reg, value_reg));
+        ctx.inst(Inst::new(OpCode::GET_PROP_DYNAMIC, Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(value_reg as u32)));
         Ok((value_reg, obj_reg))
     }
 
     fn emit_chain_call(
-        &self, call: &oxide_parser::CallExpression, short_label: Option<Label>, ctx: &mut CompileCtx,
+        &self, call: &oxide_parser::CallExpression, short_label: Option<LabelId>, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
         let (callee_reg, this_reg) = match &call.callee {
             Expression::StaticMemberExpression(member) => {
@@ -66,7 +65,7 @@ impl Compiler {
                 }
                 let key_reg = self.emit_private_id_reg(member.field.name.as_str(), ctx)?;
                 let callee_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::GET_PRIVATE, callee_reg, obj_reg, key_reg));
+                ctx.inst(Inst::new(OpCode::GET_PRIVATE, Operand::Reg(callee_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                 (callee_reg, obj_reg)
             }
             _ => {
@@ -78,7 +77,7 @@ impl Compiler {
                 }
                 let this_idx = ctx.add_constant(Constant::Undefined);
                 let this_reg = ctx.alloc_reg();
-                ctx.emit_load_const(this_reg, this_idx);
+                ctx.inst(Inst::load_const(Operand::Reg(this_reg as u32), this_idx));
                 (callee_reg, this_reg)
             }
         };
@@ -105,15 +104,32 @@ impl Compiler {
             Expression::Identifier(ident) if ctx.is_builtin(ident.name.as_str()) => OpCode::CALL_NATIVE,
             _ => OpCode::CALL,
         };
-        ctx.emit(opcode::encode(op, callee_reg, this_reg, first_arg_reg));
-        ctx.emit(arg_regs.len() as u32);
+        match op {
+            OpCode::CALL => {
+                ctx.inst(Inst::call(
+                    Operand::Reg(callee_reg as u32),
+                    Operand::Reg(this_reg as u32),
+                    Operand::Reg(first_arg_reg as u32),
+                    arg_regs.len() as u8,
+                ));
+            }
+            OpCode::CALL_NATIVE => {
+                ctx.inst(Inst::call_native(
+                    Operand::Reg(callee_reg as u32),
+                    Operand::Reg(this_reg as u32),
+                    Operand::Reg(first_arg_reg as u32),
+                    arg_regs.len() as u8,
+                ));
+            }
+            _ => unreachable!(),
+        }
         let result_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::None, Operand::None));
         Ok(result_reg)
     }
 
     fn emit_chainable_expression(
-        &self, expr: &Expression, short_label: Option<Label>, ctx: &mut CompileCtx,
+        &self, expr: &Expression, short_label: Option<LabelId>, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
         match expr {
             Expression::StaticMemberExpression(member) => {
@@ -133,7 +149,7 @@ impl Compiler {
                 }
                 let key_reg = self.emit_private_id_reg(member.field.name.as_str(), ctx)?;
                 let value_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::GET_PRIVATE, value_reg, obj_reg, key_reg));
+                ctx.inst(Inst::new(OpCode::GET_PRIVATE, Operand::Reg(value_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                 Ok(value_reg)
             }
             Expression::CallExpression(call) => self.emit_chain_call(call, short_label, ctx),
@@ -143,7 +159,7 @@ impl Compiler {
     }
 
     pub(crate) fn emit_chain_element(
-        &self, element: &ChainElement, short_label: Option<Label>, ctx: &mut CompileCtx,
+        &self, element: &ChainElement, short_label: Option<LabelId>, ctx: &mut CompileCtx,
     ) -> Result<u8, String> {
         match element {
             ChainElement::StaticMemberExpression(member) => {
@@ -163,7 +179,7 @@ impl Compiler {
                 }
                 let key_reg = self.emit_private_id_reg(member.field.name.as_str(), ctx)?;
                 let value_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::GET_PRIVATE, value_reg, obj_reg, key_reg));
+                ctx.inst(Inst::new(OpCode::GET_PRIVATE, Operand::Reg(value_reg as u32), Operand::Reg(obj_reg as u32), Operand::Reg(key_reg as u32)));
                 Ok(value_reg)
             }
             ChainElement::CallExpression(call) => self.emit_chain_call(call, short_label, ctx),
@@ -172,14 +188,14 @@ impl Compiler {
     }
 
     pub(crate) fn emit_logical_assign_test(
-        &self, op: LogicalOperator, test_reg: u8, store_label: Label, end_label: Label, ctx: &mut CompileCtx,
+        &self, op: LogicalOperator, test_reg: u8, store_label: LabelId, end_label: LabelId, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
         match op {
-            LogicalOperator::And => ctx.emit_jmp_if_false_labeled(test_reg, end_label),
-            LogicalOperator::Or => ctx.emit_jmp_if_true_labeled(test_reg, end_label),
+            LogicalOperator::And => ctx.inst(Inst::jmp_if_false(test_reg, end_label)),
+            LogicalOperator::Or => ctx.inst(Inst::jmp_if_true(test_reg, end_label)),
             LogicalOperator::Coalesce => {
-                ctx.emit_jmp_if_nullish_labeled(test_reg, store_label);
-                ctx.emit_jmp_labeled(end_label);
+                ctx.inst(Inst::jmp_if_nullish(test_reg, store_label));
+                ctx.inst(Inst::jmp(end_label));
             }
         }
         Ok(())
@@ -187,14 +203,11 @@ impl Compiler {
 
     pub(crate) fn emit_object_property_read(&self, src_reg: u8, key: &str, ctx: &mut CompileCtx) -> u8 {
         let prop_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, prop_reg, src_reg, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(prop_reg as u32), Operand::Reg(src_reg as u32), Operand::None));
         let key_idx = ctx.add_constant(Constant::String(key.to_string()));
         let key_reg = ctx.alloc_reg();
-        ctx.emit_load_const(key_reg, key_idx);
-        ctx.emit(opcode::encode(OpCode::IC_GET_PROP, 0, prop_reg, key_reg));
-        ctx.emit(0);
-        ctx.emit(0);
-        ctx.emit(0);
+        ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), key_idx));
+        ctx.inst(Inst::ic_get(Operand::Reg(prop_reg as u32), Operand::Reg(key_reg as u32)));
         prop_reg
     }
 
@@ -204,25 +217,25 @@ impl Compiler {
                 let name = ident.name.as_str();
                 let var_reg = ctx.lookup_or_builtin(name)?;
                 let key_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::LOAD_VAR, key_reg, var_reg, 0));
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(key_reg as u32), Operand::Reg(var_reg as u32), Operand::None));
                 Ok(key_reg)
             }
             PropertyKey::StringLiteral(s) => {
                 let key_idx = ctx.add_constant(Constant::String(s.value.to_string()));
                 let key_reg = ctx.alloc_reg();
-                ctx.emit_load_const(key_reg, key_idx);
+                ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), key_idx));
                 Ok(key_reg)
             }
             PropertyKey::NumericLiteral(n) => {
                 let key_idx = ctx.add_constant(Constant::Number(n.value));
                 let key_reg = ctx.alloc_reg();
-                ctx.emit_load_const(key_reg, key_idx);
+                ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), key_idx));
                 Ok(key_reg)
             }
             PropertyKey::StaticIdentifier(ident) => {
                 let key_idx = ctx.add_constant(Constant::String(ident.name.as_str().to_string()));
                 let key_reg = ctx.alloc_reg();
-                ctx.emit_load_const(key_reg, key_idx);
+                ctx.inst(Inst::load_const(Operand::Reg(key_reg as u32), key_idx));
                 Ok(key_reg)
             }
             _ => Err("computed destructuring key expression not supported".into()),
@@ -238,10 +251,10 @@ impl Compiler {
             return Ok((prop_reg, Some(key_name)));
         }
         let prop_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, prop_reg, src_reg, 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(prop_reg as u32), Operand::Reg(src_reg as u32), Operand::None));
         let key_reg = self.emit_property_key_expression(key, ctx)?;
         let val_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::GET_PROP_DYNAMIC, prop_reg, key_reg, val_reg));
+        ctx.inst(Inst::new(OpCode::GET_PROP_DYNAMIC, Operand::Reg(prop_reg as u32), Operand::Reg(key_reg as u32), Operand::Reg(val_reg as u32)));
         Ok((val_reg, None))
     }
 }

crates/oxide_compiler/src/shared/class_field.rs

@@ -1,10 +1,12 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{Expression, PropertyKey};
 
 impl Compiler {
     pub(crate) fn emit_public_field_init(
-        &self, target_reg: u8, key: &PropertyKey, computed: bool, value: Option<&Expression>, ctx: &mut CompileCtx,
+        &self, target: Operand, key: &PropertyKey, computed: bool, value: Option<&Expression>, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
         let key_reg = self.emit_class_key_reg(key, computed, ctx)?;
         let value_reg = if let Some(expr) = value {
@@ -13,15 +15,15 @@ impl Compiler {
             self.emit_undefined(ctx)
         };
         if computed {
-            ctx.emit(opcode::encode(OpCode::SET_PROP_DYNAMIC, target_reg, key_reg, value_reg));
+            ctx.inst(Inst::new(OpCode::SET_PROP_DYNAMIC, target, Operand::Reg(key_reg as u32), Operand::Reg(value_reg as u32)));
         } else {
-            ctx.emit(opcode::encode(OpCode::SET_PROP, target_reg, value_reg, key_reg));
+            ctx.inst(Inst::new(OpCode::SET_PROP, target, Operand::Reg(value_reg as u32), Operand::Reg(key_reg as u32)));
         }
         Ok(())
     }
 
     pub(crate) fn emit_private_field_init(
-        &self, target_reg: u8, name: &str, value: Option<&Expression>, ctx: &mut CompileCtx,
+        &self, target: Operand, name: &str, value: Option<&Expression>, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
         let key_reg = self.emit_private_id_reg(name, ctx)?;
         let value_reg = if let Some(expr) = value {
@@ -29,12 +31,12 @@ impl Compiler {
         } else {
             self.emit_undefined(ctx)
         };
-        ctx.emit(opcode::encode(OpCode::INIT_PRIVATE, target_reg, value_reg, key_reg));
+        ctx.inst(Inst::new(OpCode::INIT_PRIVATE, target, Operand::Reg(value_reg as u32), Operand::Reg(key_reg as u32)));
         Ok(())
     }
 
     pub(crate) fn emit_private_method_init(
-        &self, target_reg: u8, method: &oxide_parser::MethodDefinition, home_reg: u8, ctx: &mut CompileCtx,
+        &self, target: Operand, method: &oxide_parser::MethodDefinition, home_reg: Operand, ctx: &mut CompileCtx,
     ) -> Result<(), String> {
         let PropertyKey::PrivateIdentifier(private) = &method.key else {
             return Err("expected private method key".into());
@@ -42,7 +44,7 @@ impl Compiler {
         let name = private.name.as_str();
         let key_reg = self.emit_private_id_reg(name, ctx)?;
         let method_reg = self.emit_class_method_function(method, name, home_reg, ctx, &[])?;
-        ctx.emit(opcode::encode(OpCode::INIT_PRIVATE, target_reg, method_reg, key_reg));
+        ctx.inst(Inst::new(OpCode::INIT_PRIVATE, target, Operand::Reg(method_reg as u32), Operand::Reg(key_reg as u32)));
         Ok(())
     }
 }

crates/oxide_compiler/src/shared/class_key.rs

@@ -1,4 +1,6 @@
 use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
 use oxide_parser::PropertyKey;
 
@@ -15,7 +17,7 @@ impl Compiler {
         let id = self.private_name_id(name, ctx)?;
         let idx = ctx.add_constant(Constant::Int(id as i32));
         let reg = ctx.alloc_reg();
-        ctx.emit_load_const(reg, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(reg as u32), idx));
         Ok(reg)
     }
 
@@ -26,7 +28,7 @@ impl Compiler {
             let name = self.class_property_name(key)?;
             let idx = ctx.add_constant(Constant::String(name));
             let reg = ctx.alloc_reg();
-            ctx.emit_load_const(reg, idx);
+            ctx.inst(Inst::load_const(Operand::Reg(reg as u32), idx));
             return Ok(reg);
         }
 
@@ -60,7 +62,7 @@ impl Compiler {
     pub(crate) fn emit_undefined(&self, ctx: &mut CompileCtx) -> u8 {
         let idx = ctx.add_constant(Constant::Undefined);
         let reg = ctx.alloc_reg();
-        ctx.emit_load_const(reg, idx);
+        ctx.inst(Inst::load_const(Operand::Reg(reg as u32), idx));
         reg
     }
 }

crates/oxide_compiler/src/stmt/basic/break_continue.rs

@@ -1,4 +1,5 @@
 use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
 
 impl Compiler {
     pub(crate) fn emit_break_statement(
@@ -16,7 +17,7 @@ impl Compiler {
             let (bl, _) = ctx.current_loop().ok_or("break outside switch or loop".to_string())?;
             *bl
         };
-        ctx.emit_jmp_labeled(break_label);
+        ctx.inst(Inst::jmp(break_label));
         Ok(None)
     }
 
@@ -35,7 +36,7 @@ impl Compiler {
             let (_, cl) = ctx.current_loop().ok_or("continue outside loop".to_string())?;
             *cl
         };
-        ctx.emit_jmp_labeled(continue_label);
+        ctx.inst(Inst::jmp(continue_label));
         Ok(None)
     }
 }

crates/oxide_compiler/src/stmt/basic/labeled.rs

@@ -1,4 +1,4 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -22,9 +22,9 @@ impl Compiler {
             self.emit_statement(&stmt.body, ctx)?;
         } else {
             let id = ctx.next_label_id();
-            ctx.push_label_scope(name, Label::LabeledEnd(id), None)?;
+            ctx.push_label_scope(name, id, None)?;
             self.emit_statement(&stmt.body, ctx)?;
-            ctx.labels.label_map.insert(Label::LabeledEnd(id), ctx.bytecode.len());
+            ctx.labels.set_label_pos(id, ctx.insts.len());
             ctx.pop_label_scope();
         }
         Ok(None)

crates/oxide_compiler/src/stmt/basic/return_stmt.rs

@@ -1,5 +1,7 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -10,10 +12,10 @@ impl Compiler {
         match &ret.argument {
             Some(expr) => {
                 let r = self.emit_expression(expr, ctx)?;
-                ctx.emit(opcode::encode(OpCode::RETURN, r, 0, 0));
+                ctx.inst(Inst::new(OpCode::RETURN, Operand::Reg(r as u32), Operand::None, Operand::None));
             }
             None => {
-                ctx.emit(opcode::encode(OpCode::RETURN, 0, 0, 0));
+                ctx.inst(Inst::new(OpCode::RETURN, Operand::None, Operand::None, Operand::None));
             }
         }
         Ok(None)

crates/oxide_compiler/src/stmt/control.rs

@@ -1,6 +1,8 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
 use oxide_bytecode::module::Constant;
-use oxide_bytecode::opcode::{self, OpCode};
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -8,39 +10,38 @@ impl Compiler {
         let Statement::IfStatement(ifs) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let else_label = Label::IfElse(id);
-        let end_label = Label::IfEnd(id);
+        let else_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
 
         let test_reg = self.emit_expression(&ifs.test, ctx)?;
 
-        ctx.emit_jmp_if_false_labeled(test_reg, else_label);
+        ctx.inst(Inst::jmp_if_false(test_reg, else_label));
 
         let cons_reg = self.emit_statement(&ifs.consequent, ctx)?;
         let result_reg = ctx.alloc_reg();
         if let Some(r) = cons_reg {
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, r, 0));
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(r as u32), Operand::None));
         } else {
             let undef_idx = ctx.add_constant(Constant::Undefined);
-            ctx.emit_load_const(result_reg, undef_idx);
+            ctx.inst(Inst::load_const(Operand::Reg(result_reg as u32), undef_idx));
         }
 
         if ifs.alternate.is_some() {
-            ctx.emit_jmp_labeled(end_label);
+            ctx.inst(Inst::jmp(end_label));
         }
 
-        ctx.labels.label_map.insert(else_label, ctx.bytecode.len());
+        ctx.labels.set_label_pos(else_label, ctx.insts.len());
         if let Some(alt) = &ifs.alternate {
             let alt_reg = self.emit_statement(alt, ctx)?;
             if let Some(r) = alt_reg {
-                ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, r, 0));
+                ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(r as u32), Operand::None));
             } else {
                 let undef_idx = ctx.add_constant(Constant::Undefined);
-                ctx.emit_load_const(result_reg, undef_idx);
+                ctx.inst(Inst::load_const(Operand::Reg(result_reg as u32), undef_idx));
             }
         }
 
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
 
         Ok(Some(result_reg))
     }

crates/oxide_compiler/src/stmt/declaration/class_decl.rs

@@ -1,5 +1,7 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{Statement, VariableDeclarationKind};
 
 impl Compiler {
@@ -18,7 +20,7 @@ impl Compiler {
         ctx.declare(&name, var_reg, VariableDeclarationKind::Let, false)?;
         ctx.init_var(&name);
         let ctor_reg = self.emit_class(class, ctx)?;
-        ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, ctor_reg, 0));
+        ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(ctor_reg as u32), Operand::None));
         Ok(None)
     }
 }

crates/oxide_compiler/src/stmt/declaration/function_decl.rs

@@ -1,5 +1,7 @@
 use crate::compiler::{CompileCtx, Compiler, ParamSpec};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -29,12 +31,11 @@ impl Compiler {
         let body_stmts: &[Statement] = if let Some(body) = &fd.body { &body.statements } else { &[] };
         let mut sub_module = self.compile_function_body(&param_names, body_stmts, ctx, false, false)?;
         sub_module.function_name = Some(name.clone());
-        ctx.sub_modules.push(sub_module);
-        let sub_idx = ctx.sub_modules.len() as u32;
+        ctx.nested.push(sub_module);
         let var_reg = ctx.lookup(&name)?;
         ctx.reserve_reg(var_reg);
-        ctx.emit_create_closure(var_reg, sub_idx);
-        ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, var_reg, 0));
+        ctx.inst(Inst::create_closure(Operand::Reg(var_reg as u32), ctx.nested.len() as u16));
+        ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(var_reg as u32), Operand::None));
         Ok(None)
     }
 }

crates/oxide_compiler/src/stmt/declaration/var.rs

@@ -1,8 +1,8 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::{
-    module::Constant,
-    opcode::{self, OpCode},
-};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::module::Constant;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{BindingPattern, Expression, Statement, VariableDeclarationKind};
 
 impl Compiler {
@@ -23,7 +23,7 @@ impl Compiler {
                 self.emit_binding_pattern(&d.id, val_reg, decl.kind, is_const, ctx)?;
                 if let BindingPattern::BindingIdentifier(bi) = &d.id {
                     if matches!(*init, Expression::ArrowFunctionExpression(_)) {
-                        if let Some(sub_mod) = ctx.sub_modules.last_mut() {
+                        if let Some(sub_mod) = ctx.nested.last_mut() {
                             sub_mod.function_name = Some(bi.name.to_string());
                         }
                     }
@@ -35,7 +35,7 @@ impl Compiler {
                 };
                 let idx = ctx.add_constant(Constant::Undefined);
                 let tmp = ctx.alloc_reg();
-                ctx.emit_load_const(tmp, idx);
+                ctx.inst(Inst::load_const(Operand::Reg(tmp as u32), idx));
                 let var_reg = ctx.alloc_reg();
                 let target_reg = if matches!(decl.kind, VariableDeclarationKind::Var) {
                     match ctx.declare(bi.name.as_str(), var_reg, decl.kind, is_const) {
@@ -50,9 +50,9 @@ impl Compiler {
                 if is_captured {
                     let cell_idx = ctx.scopes.cell_registry.len() as u8;
                     ctx.scopes.cell_registry.push((bi.name.to_string(), cell_idx));
-                    ctx.emit(opcode::encode(OpCode::MAKE_CELL, tmp, cell_idx, 0));
+                    ctx.inst(Inst::new(OpCode::MAKE_CELL, Operand::Reg(tmp as u32), Operand::Reg(cell_idx as u32), Operand::None));
                 } else {
-                    ctx.emit(opcode::encode(OpCode::STORE_VAR, target_reg, tmp, 0));
+                    ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(target_reg as u32), Operand::Reg(tmp as u32), Operand::None));
                 }
                 ctx.init_var(bi.name.as_str());
                 r = Some(var_reg);

crates/oxide_compiler/src/stmt/exception/throw.rs

@@ -1,5 +1,7 @@
 use crate::compiler::{CompileCtx, Compiler};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -8,7 +10,7 @@ impl Compiler {
             return Ok(None);
         };
         let exc_reg = self.emit_expression(&ts.argument, ctx)?;
-        ctx.emit(opcode::encode(OpCode::THROW, exc_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::THROW, Operand::Reg(exc_reg as u32), Operand::None, Operand::None));
         Ok(None)
     }
 }

crates/oxide_compiler/src/stmt/exception/try_catch.rs

@@ -1,5 +1,7 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{Statement, VariableDeclarationKind};
 
 impl Compiler {
@@ -7,18 +9,17 @@ impl Compiler {
         let Statement::TryStatement(ts) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let catch_label = Label::CatchBody(id);
-        let finally_label = Label::FinallyBody(id);
-        let try_end_label = Label::TryEnd(id);
+        let catch_label = ctx.next_label_id();
+        let finally_label = ctx.next_label_id();
+        let try_end_label = ctx.next_label_id();
         let has_catch = ts.handler.is_some();
         let has_finally = ts.finalizer.is_some();
         let result_reg = ctx.alloc_reg();
         if has_finally {
-            ctx.emit_try_finally_begin_labeled(finally_label);
+            ctx.inst(Inst::try_finally_begin(finally_label));
         }
         if has_catch {
-            ctx.emit_try_begin_labeled(catch_label);
+            ctx.inst(Inst::try_begin(catch_label));
         }
         let mut last_try_result: Option<u8> = None;
         for s in &ts.block.body {
@@ -26,24 +27,23 @@ impl Compiler {
                 last_try_result = Some(r);
             }
         }
-        ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, last_try_result.unwrap_or(result_reg), 0));
+        ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(last_try_result.unwrap_or(result_reg) as u32), Operand::None));
         if has_catch {
-            ctx.emit(opcode::encode(OpCode::TRY_END, 0, 0, 0));
+            ctx.inst(Inst::new(OpCode::TRY_END, Operand::None, Operand::None, Operand::None));
         }
         let jmp_needed = has_catch || has_finally;
         if jmp_needed {
             let target = if has_finally { finally_label } else { try_end_label };
-            ctx.emit_jmp_labeled(target);
+            ctx.inst(Inst::jmp(target));
         }
-        let catch_label_pc = ctx.bytecode.len();
-        ctx.labels.label_map.insert(catch_label, catch_label_pc);
+        ctx.labels.set_label_pos(catch_label, ctx.insts.len());
         if let Some(catch) = &ts.handler {
             ctx.push_scope();
             if let Some(param) = &catch.param {
                 let catch_reg = ctx.alloc_reg();
                 if let oxide_parser::BindingPattern::BindingIdentifier(bi) = &param.pattern {
                     ctx.declare_initialized(bi.name.as_str(), catch_reg, VariableDeclarationKind::Let, false)?;
-                    ctx.emit(opcode::encode(OpCode::STORE_VAR, catch_reg, 0, 0));
+                    ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(catch_reg as u32), Operand::None, Operand::None));
                 }
             }
             let mut last_catch_result: Option<u8> = None;
@@ -52,22 +52,21 @@ impl Compiler {
                     last_catch_result = Some(r);
                 }
             }
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, last_catch_result.unwrap_or(result_reg), 0));
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(last_catch_result.unwrap_or(result_reg) as u32), Operand::None));
             ctx.pop_scope();
         }
         if has_finally {
-            ctx.labels.label_map.insert(finally_label, ctx.bytecode.len());
+            ctx.labels.set_label_pos(finally_label, ctx.insts.len());
             let mut last_finally_result: Option<u8> = None;
             for s in &ts.finalizer.as_ref().unwrap().body {
                 if let Some(r) = self.emit_statement(s, ctx)? {
                     last_finally_result = Some(r);
                 }
             }
-            ctx.emit(opcode::encode(OpCode::LOAD_VAR, result_reg, last_finally_result.unwrap_or(result_reg), 0));
-            ctx.emit(opcode::encode(OpCode::TRY_FINALLY_END, 0, 0, 0));
+            ctx.inst(Inst::new(OpCode::LOAD_VAR, Operand::Reg(result_reg as u32), Operand::Reg(last_finally_result.unwrap_or(result_reg) as u32), Operand::None));
+            ctx.inst(Inst::new(OpCode::TRY_FINALLY_END, Operand::None, Operand::None, Operand::None));
         }
-        let try_end_pc = ctx.bytecode.len();
-        ctx.labels.label_map.insert(try_end_label, try_end_pc);
+        ctx.labels.set_label_pos(try_end_label, ctx.insts.len());
         Ok(Some(result_reg))
     }
 }

crates/oxide_compiler/src/stmt/iteration/do_while.rs

@@ -1,4 +1,5 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -6,16 +7,15 @@ impl Compiler {
         let Statement::DoWhileStatement(dw) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let start_label = Label::DoWhileStart(id);
-        let end_label = Label::DoWhileEnd(id);
-        ctx.labels.label_map.insert(start_label, ctx.bytecode.len());
+        let start_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
+        ctx.labels.set_label_pos(start_label, ctx.insts.len());
         ctx.push_loop(end_label, start_label);
         let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
         self.emit_statement(&dw.body, ctx)?;
         let test_reg = self.emit_expression(&dw.test, ctx)?;
-        ctx.emit_jmp_if_true_labeled(test_reg, start_label);
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.inst(Inst::jmp_if_true(test_reg, start_label));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
         ctx.pop_label_scopes(n_labeled);
         ctx.pop_loop();
         Ok(None)

crates/oxide_compiler/src/stmt/iteration/for_.rs

@@ -1,8 +1,8 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
-use oxide_bytecode::{
-    module::Constant,
-    opcode::{self, OpCode},
-};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::module::Constant;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{BindingPattern, ForStatementInit, Statement, VariableDeclarationKind};
 
 impl Compiler {
@@ -10,10 +10,9 @@ impl Compiler {
         let Statement::ForStatement(fr) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let start_label = Label::ForStart(id);
-        let update_label = Label::ForUpdate(id);
-        let end_label = Label::ForEnd(id);
+        let start_label = ctx.next_label_id();
+        let update_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
         ctx.push_loop(end_label, update_label);
         let n_labeled = ctx.take_pending_loop_labels(end_label, update_label);
         if let Some(init) = &fr.init {
@@ -28,7 +27,7 @@ impl Compiler {
                     } else if let BindingPattern::BindingIdentifier(bi) = &d.id {
                         let idx = ctx.add_constant(Constant::Undefined);
                         let tmp = ctx.alloc_reg();
-                        ctx.emit_load_const(tmp, idx);
+                        ctx.inst(Inst::load_const(Operand::Reg(tmp as u32), idx));
                         let var_reg = ctx.alloc_reg();
                         let target_reg = if matches!(decl.kind, VariableDeclarationKind::Var) {
                             match ctx.declare(bi.name.as_str(), var_reg, decl.kind, is_const) {
@@ -39,24 +38,24 @@ impl Compiler {
                             ctx.declare(bi.name.as_str(), var_reg, decl.kind, is_const)?;
                             var_reg
                         };
-                        ctx.emit(opcode::encode(OpCode::STORE_VAR, target_reg, tmp, 0));
+                        ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(target_reg as u32), Operand::Reg(tmp as u32), Operand::None));
                         ctx.init_var(bi.name.as_str());
                     }
                 }
             }
         }
-        ctx.labels.label_map.insert(start_label, ctx.bytecode.len());
+        ctx.labels.set_label_pos(start_label, ctx.insts.len());
         if let Some(test) = &fr.test {
             let test_reg = self.emit_expression(test, ctx)?;
-            ctx.emit_jmp_if_false_labeled(test_reg, end_label);
+            ctx.inst(Inst::jmp_if_false(test_reg, end_label));
         }
         self.emit_statement(&fr.body, ctx)?;
-        ctx.labels.label_map.insert(update_label, ctx.bytecode.len());
+        ctx.labels.set_label_pos(update_label, ctx.insts.len());
         if let Some(update) = &fr.update {
             self.emit_expression(update, ctx)?;
         }
-        ctx.emit_jmp_labeled(start_label);
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.inst(Inst::jmp(start_label));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
         ctx.pop_label_scopes(n_labeled);
         ctx.pop_loop();
         Ok(None)

crates/oxide_compiler/src/stmt/iteration/for_in.rs

@@ -1,5 +1,7 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{ForStatementLeft, Statement, VariableDeclarationKind};
 
 impl Compiler {
@@ -7,20 +9,22 @@ impl Compiler {
         let Statement::ForInStatement(fi) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let start_label = Label::ForInStart(id);
-        let end_label = Label::ForInEnd(id);
+        let start_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
         let obj_reg = self.emit_expression(&fi.right, ctx)?;
-        ctx.emit(opcode::encode(OpCode::FOR_IN_INIT, 0, obj_reg, 0));
-        ctx.labels.label_map.insert(start_label, ctx.bytecode.len());
+        ctx.inst(Inst::new(OpCode::FOR_IN_INIT, Operand::None, Operand::Reg(obj_reg as u32), Operand::None));
+        ctx.labels.set_label_pos(start_label, ctx.insts.len());
         ctx.push_loop(end_label, start_label);
         let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
         let done_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::FOR_IN_DONE, done_reg, 0, 0));
-        ctx.emit(opcode::encode_jmp_if_false(done_reg, 2));
-        ctx.emit_jmp_labeled(end_label);
+        ctx.inst(Inst::new(OpCode::FOR_IN_DONE, Operand::Reg(done_reg as u32), Operand::None, Operand::None));
+        // done=true 表示迭代结束：done=false 时跳过 end jmp 继续迭代
+        let continue_label = ctx.next_label_id();
+        ctx.inst(Inst::jmp_if_false(done_reg, continue_label));
+        ctx.inst(Inst::jmp(end_label));
+        ctx.labels.set_label_pos(continue_label, ctx.insts.len());
         let key_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::FOR_IN_NEXT, key_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::FOR_IN_NEXT, Operand::Reg(key_reg as u32), Operand::None, Operand::None));
         match &fi.left {
             ForStatementLeft::VariableDeclaration(decl) => {
                 for d in &decl.declarations {
@@ -30,21 +34,21 @@ impl Compiler {
                     };
                     let var_reg = ctx.alloc_reg();
                     ctx.declare(name, var_reg, decl.kind, matches!(decl.kind, VariableDeclarationKind::Const))?;
-                    ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, key_reg, 0));
+                    ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(key_reg as u32), Operand::None));
                     ctx.init_var(name);
                 }
             }
             ForStatementLeft::AssignmentTargetIdentifier(id_ref) => {
                 let name = id_ref.name.as_str();
                 let var_reg = ctx.lookup_or_global(name);
-                ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, key_reg, 0));
+                ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(key_reg as u32), Operand::None));
             }
             _ => return Err("unsupported for-in left-hand side".into()),
         }
         self.emit_statement(&fi.body, ctx)?;
-        ctx.emit_jmp_labeled(start_label);
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
-        ctx.emit(opcode::encode(OpCode::FOR_IN_CLEANUP, 0, 0, 0));
+        ctx.inst(Inst::jmp(start_label));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
+        ctx.inst(Inst::new(OpCode::FOR_IN_CLEANUP, Operand::None, Operand::None, Operand::None));
         ctx.pop_label_scopes(n_labeled);
         ctx.pop_loop();
         Ok(None)

crates/oxide_compiler/src/stmt/iteration/for_of.rs

@@ -1,5 +1,7 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::{ForStatementLeft, Statement};
 
 impl Compiler {
@@ -7,19 +9,18 @@ impl Compiler {
         let Statement::ForOfStatement(fo) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let start_label = Label::ForOfStart(id);
-        let end_label = Label::ForOfEnd(id);
+        let start_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
         let iter_src_reg = self.emit_expression(&fo.right, ctx)?;
-        ctx.emit(opcode::encode(OpCode::FOR_OF_INIT, 0, iter_src_reg, 0));
-        ctx.labels.label_map.insert(start_label, ctx.bytecode.len());
+        ctx.inst(Inst::new(OpCode::FOR_OF_INIT, Operand::None, Operand::Reg(iter_src_reg as u32), Operand::None));
+        ctx.labels.set_label_pos(start_label, ctx.insts.len());
         ctx.push_loop(end_label, start_label);
         let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
         let has_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::FOR_OF_DONE, has_reg, 0, 0));
-        ctx.emit_jmp_if_false_labeled(has_reg, end_label);
+        ctx.inst(Inst::new(OpCode::FOR_OF_DONE, Operand::Reg(has_reg as u32), Operand::None, Operand::None));
+        ctx.inst(Inst::jmp_if_false(has_reg, end_label));
         let val_reg = ctx.alloc_reg();
-        ctx.emit(opcode::encode(OpCode::FOR_OF_NEXT, val_reg, 0, 0));
+        ctx.inst(Inst::new(OpCode::FOR_OF_NEXT, Operand::Reg(val_reg as u32), Operand::None, Operand::None));
         match &fo.left {
             ForStatementLeft::VariableDeclaration(decl) => {
                 for d in &decl.declarations {
@@ -29,7 +30,7 @@ impl Compiler {
             ForStatementLeft::AssignmentTargetIdentifier(id_ref) => {
                 let name = id_ref.name.as_str();
                 let var_reg = ctx.lookup_or_global(name);
-                ctx.emit(opcode::encode(OpCode::STORE_VAR, var_reg, val_reg, 0));
+                ctx.inst(Inst::new(OpCode::STORE_VAR, Operand::Reg(var_reg as u32), Operand::Reg(val_reg as u32), Operand::None));
             }
             ForStatementLeft::ArrayAssignmentTarget(ap) => {
                 self.emit_array_assignment(ap, val_reg, ctx)?;
@@ -40,9 +41,9 @@ impl Compiler {
             _ => return Err("unsupported for-of left-hand side".into()),
         }
         self.emit_statement(&fo.body, ctx)?;
-        ctx.emit_jmp_labeled(start_label);
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
-        ctx.emit(opcode::encode(OpCode::FOR_OF_CLOSE, 0, 0, 0));
+        ctx.inst(Inst::jmp(start_label));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
+        ctx.inst(Inst::new(OpCode::FOR_OF_CLOSE, Operand::None, Operand::None, Operand::None));
         ctx.pop_label_scopes(n_labeled);
         ctx.pop_loop();
         Ok(None)

crates/oxide_compiler/src/stmt/iteration/while_loop.rs

@@ -1,4 +1,5 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -6,17 +7,16 @@ impl Compiler {
         let Statement::WhileStatement(wh) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let start_label = Label::WhileStart(id);
-        let end_label = Label::WhileEnd(id);
-        ctx.labels.label_map.insert(start_label, ctx.bytecode.len());
+        let start_label = ctx.next_label_id();
+        let end_label = ctx.next_label_id();
+        ctx.labels.set_label_pos(start_label, ctx.insts.len());
         ctx.push_loop(end_label, start_label);
         let n_labeled = ctx.take_pending_loop_labels(end_label, start_label);
         let test_reg = self.emit_expression(&wh.test, ctx)?;
-        ctx.emit_jmp_if_false_labeled(test_reg, end_label);
+        ctx.inst(Inst::jmp_if_false(test_reg, end_label));
         self.emit_statement(&wh.body, ctx)?;
-        ctx.emit_jmp_labeled(start_label);
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.inst(Inst::jmp(start_label));
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
         ctx.pop_label_scopes(n_labeled);
         ctx.pop_loop();
         Ok(None)

crates/oxide_compiler/src/stmt/switch.rs

@@ -1,5 +1,7 @@
-use crate::compiler::{CompileCtx, Compiler, Label};
-use oxide_bytecode::opcode::{self, OpCode};
+use crate::compiler::{CompileCtx, Compiler};
+use crate::ir::inst::Inst;
+use crate::ir::operand::Operand;
+use oxide_bytecode::opcode::OpCode;
 use oxide_parser::Statement;
 
 impl Compiler {
@@ -7,34 +9,35 @@ impl Compiler {
         let Statement::SwitchStatement(sw) = stmt else {
             return Ok(None);
         };
-        let id = ctx.next_label_id();
-        let end_label = Label::SwitchEnd(id);
+        let end_label = ctx.next_label_id();
         ctx.push_switch(end_label);
         let disc_reg = self.emit_expression(&sw.discriminant, ctx)?;
         let compare_reg_checkpoint = ctx.reg_checkpoint();
         let cases = &sw.cases;
-        for (case_idx, case) in cases.iter().enumerate() {
+        let mut case_labels = Vec::with_capacity(cases.len());
+        for case in cases.iter() {
+            let case_label = ctx.next_label_id();
+            case_labels.push(case_label);
             if let Some(test) = &case.test {
                 let test_reg = self.emit_expression(test, ctx)?;
                 let eq_reg = ctx.alloc_reg();
-                ctx.emit(opcode::encode(OpCode::EQ, eq_reg, disc_reg, test_reg));
-                let case_label = Label::SwitchCase(id, case_idx as u32);
-                ctx.emit_jmp_if_true_labeled(eq_reg, case_label);
+                ctx.inst(Inst::new(OpCode::EQ, Operand::Reg(eq_reg as u32), Operand::Reg(disc_reg as u32), Operand::Reg(test_reg as u32)));
+                ctx.inst(Inst::jmp_if_true(eq_reg, case_label));
                 ctx.restore_reg_checkpoint(compare_reg_checkpoint);
             }
         }
         let has_default = cases.iter().any(|c| c.test.is_none());
         if !has_default {
-            ctx.emit_jmp_labeled(end_label);
+            ctx.inst(Inst::jmp(end_label));
         }
         for (case_idx, case) in cases.iter().enumerate() {
-            let case_label = Label::SwitchCase(id, case_idx as u32);
-            ctx.labels.label_map.insert(case_label, ctx.bytecode.len());
+            let case_label = case_labels[case_idx];
+            ctx.labels.set_label_pos(case_label, ctx.insts.len());
             for s in &case.consequent {
                 self.emit_statement(s, ctx)?;
             }
         }
-        ctx.labels.label_map.insert(end_label, ctx.bytecode.len());
+        ctx.labels.set_label_pos(end_label, ctx.insts.len());
         ctx.pop_switch();
         Ok(None)
     }