From e7c8330bab0ebf477019ce92a1d50cca012469c2 Mon Sep 17 00:00:00 2001
From: Haled Odat <8566042+HalidOdat@users.noreply.github.com>
Date: Mon, 26 Jun 2023 09:13:34 +0200
Subject: [PATCH] Refactor environment, exception handling and jumping in VM

---
 boa_engine/src/builtins/eval/mod.rs           |   5 +-
 boa_engine/src/builtins/json/mod.rs           |   5 +-
 .../declaration/declaration_pattern.rs        |  48 ++-
 boa_engine/src/bytecompiler/env.rs            |   2 +
 boa_engine/src/bytecompiler/jump_control.rs   | 307 +++++++++++-------
 boa_engine/src/bytecompiler/mod.rs            |  35 +-
 .../src/bytecompiler/statement/break.rs       | 106 +++---
 .../src/bytecompiler/statement/continue.rs    | 147 +++------
 .../src/bytecompiler/statement/labelled.rs    |   9 +-
 boa_engine/src/bytecompiler/statement/loop.rs |  56 ++--
 boa_engine/src/bytecompiler/statement/mod.rs  |  39 +++
 .../src/bytecompiler/statement/switch.rs      |   5 -
 boa_engine/src/bytecompiler/statement/try.rs  |  83 +++--
 boa_engine/src/module/source.rs               |   3 +-
 boa_engine/src/script.rs                      |   5 +-
 boa_engine/src/vm/call_frame/abrupt_record.rs |  89 -----
 boa_engine/src/vm/call_frame/env_stack.rs     | 201 ------------
 boa_engine/src/vm/call_frame/mod.rs           |  47 +--
 boa_engine/src/vm/code_block.rs               | 105 +++++-
 boa_engine/src/vm/flowgraph/mod.rs            | 235 ++++++--------
 boa_engine/src/vm/mod.rs                      |  24 +-
 boa_engine/src/vm/opcode/await_stm/mod.rs     |   3 +-
 .../src/vm/opcode/control_flow/break.rs       |  54 ---
 .../src/vm/opcode/control_flow/continue.rs    |  67 ----
 .../src/vm/opcode/control_flow/finally.rs     | 148 ---------
 .../src/vm/opcode/control_flow/labelled.rs    |  55 ----
 boa_engine/src/vm/opcode/control_flow/mod.rs  |  10 -
 .../src/vm/opcode/control_flow/return.rs      |  36 +-
 .../src/vm/opcode/control_flow/throw.rs       | 224 ++++---------
 boa_engine/src/vm/opcode/control_flow/try.rs  |  68 ----
 .../src/vm/opcode/generator/yield_stm.rs      |   5 +-
 .../src/vm/opcode/iteration/iterator.rs       |  57 ++++
 .../src/vm/opcode/iteration/loop_ops.rs       | 105 +-----
 boa_engine/src/vm/opcode/jump/mod.rs          |  37 ++-
 boa_engine/src/vm/opcode/mod.rs               | 120 +++----
 boa_engine/src/vm/opcode/pop/mod.rs           |   1 -
 boa_engine/src/vm/opcode/push/environment.rs  |   2 -
 37 files changed, 953 insertions(+), 1595 deletions(-)
 delete mode 100644 boa_engine/src/vm/call_frame/abrupt_record.rs
 delete mode 100644 boa_engine/src/vm/call_frame/env_stack.rs
 delete mode 100644 boa_engine/src/vm/opcode/control_flow/break.rs
 delete mode 100644 boa_engine/src/vm/opcode/control_flow/continue.rs
 delete mode 100644 boa_engine/src/vm/opcode/control_flow/finally.rs
 delete mode 100644 boa_engine/src/vm/opcode/control_flow/labelled.rs
 delete mode 100644 boa_engine/src/vm/opcode/control_flow/try.rs

diff --git a/boa_engine/src/builtins/eval/mod.rs b/boa_engine/src/builtins/eval/mod.rs
index 9d7c4946fb0..ab3e25b1b8d 100644
--- a/boa_engine/src/builtins/eval/mod.rs
+++ b/boa_engine/src/builtins/eval/mod.rs
@@ -253,7 +253,10 @@ impl Eval {
             context.vm.environments.extend_outer_function_environment();
         }
 
-        context.vm.push_frame(CallFrame::new(code_block));
+        let env_fp = context.vm.environments.len() as u32;
+        context
+            .vm
+            .push_frame(CallFrame::new(code_block).with_env_fp(env_fp));
         context.realm().resize_global_env();
         let record = context.run();
         context.vm.pop_frame();
diff --git a/boa_engine/src/builtins/json/mod.rs b/boa_engine/src/builtins/json/mod.rs
index 20b80fef102..67fd9a41bce 100644
--- a/boa_engine/src/builtins/json/mod.rs
+++ b/boa_engine/src/builtins/json/mod.rs
@@ -128,7 +128,10 @@ impl Json {
             Gc::new(compiler.finish())
         };
 
-        context.vm.push_frame(CallFrame::new(code_block));
+        let env_fp = context.vm.environments.len() as u32;
+        context
+            .vm
+            .push_frame(CallFrame::new(code_block).with_env_fp(env_fp));
         context.realm().resize_global_env();
         let record = context.run();
         context.vm.pop_frame();
diff --git a/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs b/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs
index 9801c63bd3d..98aa84b7fbf 100644
--- a/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs
+++ b/boa_engine/src/bytecompiler/declaration/declaration_pattern.rs
@@ -180,11 +180,45 @@ impl ByteCompiler<'_, '_> {
                 self.emit_opcode(Opcode::ValueNotNullOrUndefined);
                 self.emit_opcode(Opcode::GetIterator);
 
+                // TODO: maybe, refactor this to be more condensed.
+                let handler_index = self.push_handler();
                 for element in pattern.bindings() {
                     self.compile_array_pattern_element(element, def);
                 }
+                let handler_end_address = self.next_opcode_location();
 
+                self.emit_opcode(Opcode::PushFalse);
+
+                let exit = self.jump();
+                let handler_address = self.next_opcode_location();
+                self.emit_opcode(Opcode::Exception);
+                self.emit_opcode(Opcode::PushTrue);
+                self.patch_jump(exit);
+
+                self.handlers[handler_index as usize].handler = handler_address;
+                self.handlers[handler_index as usize].range.end = handler_end_address;
+
+                let iterator_close_handler = self.push_handler();
                 self.iterator_close(false);
+
+                let exit = self.jump();
+                let iterator_close_handler_address = self.next_opcode_location();
+                {
+                    let jump = self.jump_if_false();
+                    self.emit_opcode(Opcode::Throw);
+                    self.patch_jump(jump);
+                }
+                self.emit_opcode(Opcode::ReThrow);
+                self.patch_jump(exit);
+
+                let jump = self.jump_if_false();
+                self.emit_opcode(Opcode::Throw);
+                self.patch_jump(jump);
+
+                self.handlers[iterator_close_handler as usize].handler =
+                    iterator_close_handler_address;
+                self.handlers[iterator_close_handler as usize].range.end =
+                    iterator_close_handler_address;
             }
         }
     }
@@ -198,15 +232,15 @@ impl ByteCompiler<'_, '_> {
         match element {
             // ArrayBindingPattern : [ Elision ]
             Elision => {
-                self.emit_opcode(Opcode::IteratorNext);
+                self.emit_opcode(Opcode::IteratorNextWithoutPop);
             }
             // SingleNameBinding : BindingIdentifier Initializer[opt]
             SingleName {
                 ident,
                 default_init,
             } => {
-                self.emit_opcode(Opcode::IteratorNext);
-                self.emit_opcode(Opcode::IteratorValue);
+                self.emit_opcode(Opcode::IteratorNextWithoutPop);
+                self.emit_opcode(Opcode::IteratorValueWithoutPop);
                 if let Some(init) = default_init {
                     let skip = self.emit_opcode_with_operand(Opcode::JumpIfNotUndefined);
                     self.compile_expr(init, true);
@@ -216,8 +250,8 @@ impl ByteCompiler<'_, '_> {
             }
             PropertyAccess { access } => {
                 self.access_set(Access::Property { access }, false, |compiler, _level| {
-                    compiler.emit_opcode(Opcode::IteratorNext);
-                    compiler.emit_opcode(Opcode::IteratorValue);
+                    compiler.emit_opcode(Opcode::IteratorNextWithoutPop);
+                    compiler.emit_opcode(Opcode::IteratorValueWithoutPop);
                 });
             }
             // BindingElement : BindingPattern Initializer[opt]
@@ -225,8 +259,8 @@ impl ByteCompiler<'_, '_> {
                 pattern,
                 default_init,
             } => {
-                self.emit_opcode(Opcode::IteratorNext);
-                self.emit_opcode(Opcode::IteratorValue);
+                self.emit_opcode(Opcode::IteratorNextWithoutPop);
+                self.emit_opcode(Opcode::IteratorValueWithoutPop);
 
                 if let Some(init) = default_init {
                     let skip = self.emit_opcode_with_operand(Opcode::JumpIfNotUndefined);
diff --git a/boa_engine/src/bytecompiler/env.rs b/boa_engine/src/bytecompiler/env.rs
index fb3be0b9e75..c817b5b7944 100644
--- a/boa_engine/src/bytecompiler/env.rs
+++ b/boa_engine/src/bytecompiler/env.rs
@@ -7,6 +7,7 @@ use boa_ast::expression::Identifier;
 impl ByteCompiler<'_, '_> {
     /// Push either a new declarative or function environment on the compile time environment stack.
     pub(crate) fn push_compile_environment(&mut self, function_scope: bool) {
+        self.current_open_environments_count += 1;
         self.current_environment = Rc::new(CompileTimeEnvironment::new(
             self.current_environment.clone(),
             function_scope,
@@ -16,6 +17,7 @@ impl ByteCompiler<'_, '_> {
     /// Pops the top compile time environment and returns its index in the compile time environments array.
     #[track_caller]
     pub(crate) fn pop_compile_environment(&mut self) -> u32 {
+        self.current_open_environments_count -= 1;
         let index = self.compile_environments.len() as u32;
         self.compile_environments
             .push(self.current_environment.clone());
diff --git a/boa_engine/src/bytecompiler/jump_control.rs b/boa_engine/src/bytecompiler/jump_control.rs
index 0c86fbd0ba4..a200338cbe0 100644
--- a/boa_engine/src/bytecompiler/jump_control.rs
+++ b/boa_engine/src/bytecompiler/jump_control.rs
@@ -9,19 +9,103 @@
 //! [try spec]: https://tc39.es/ecma262/#sec-try-statement
 //! [labelled spec]: https://tc39.es/ecma262/#sec-labelled-statements
 
-use crate::bytecompiler::{ByteCompiler, Label};
+use crate::{
+    bytecompiler::{ByteCompiler, Label},
+    vm::{Handler, Opcode},
+};
 use bitflags::bitflags;
 use boa_interner::Sym;
 
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum JumpRecordAction {
+    CreateJump,
+    Transfter { index: u32 },
+    PopEnvironments { count: u32 },
+    HandleFinally { value: i32 },
+    CloseIterator { r#async: bool },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum JumpRecordKind {
+    Break,
+    Continue,
+    Return,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct JumpRecord {
+    kind: JumpRecordKind,
+    label: Label,
+    actions: Vec<JumpRecordAction>,
+}
+
+impl JumpRecord {
+    pub(crate) const fn new(
+        kind: JumpRecordKind,
+        label: Label,
+        actions: Vec<JumpRecordAction>,
+    ) -> Self {
+        Self {
+            kind,
+            label,
+            actions,
+        }
+    }
+
+    pub(crate) fn perform_actions(
+        mut self,
+        start_address: u32,
+        compiler: &mut ByteCompiler<'_, '_>,
+    ) {
+        while let Some(action) = self.actions.pop() {
+            match action {
+                JumpRecordAction::Transfter { index } => {
+                    compiler.jump_info[index as usize].jumps.push(self);
+                    return;
+                }
+                JumpRecordAction::PopEnvironments { count } => {
+                    for _ in 0..count {
+                        compiler.emit_opcode(Opcode::PopEnvironment);
+                    }
+                }
+                JumpRecordAction::HandleFinally { value } => {
+                    compiler.emit_push_integer(value);
+                    compiler.emit_opcode(Opcode::PushFalse);
+                }
+                JumpRecordAction::CreateJump => {
+                    self.label = compiler.jump();
+                }
+                JumpRecordAction::CloseIterator { r#async } => {
+                    compiler.iterator_close(r#async);
+                }
+            }
+        }
+
+        match self.kind {
+            JumpRecordKind::Break => compiler.patch_jump(self.label),
+            JumpRecordKind::Continue => compiler.patch_jump_with_target(self.label, start_address),
+            JumpRecordKind::Return if start_address != ByteCompiler::DUMMY_ADDRESS => {
+                compiler.returns_to_patch.push(Label {
+                    index: start_address,
+                });
+            }
+            JumpRecordKind::Return => {
+                compiler.emit_opcode(Opcode::Return);
+            }
+        }
+    }
+}
+
 /// Boa's `ByteCompiler` jump information tracking struct.
 #[derive(Debug, Clone)]
 pub(crate) struct JumpControlInfo {
     label: Option<Sym>,
     start_address: u32,
-    flags: JumpControlInfoFlags,
-    set_jumps: Vec<Label>,
-    breaks: Vec<Label>,
-    try_continues: Vec<Label>,
+    pub(crate) flags: JumpControlInfoFlags,
+    pub(crate) jumps: Vec<JumpRecord>,
+    current_open_environments_count: u32,
+
+    handler_index: Option<u32>,
 }
 
 bitflags! {
@@ -32,7 +116,6 @@ bitflags! {
         const SWITCH = 0b0000_0010;
         const TRY_BLOCK = 0b0000_0100;
         const LABELLED = 0b0000_1000;
-        const IN_FINALLY = 0b0001_0000;
         const HAS_FINALLY = 0b0010_0000;
         const ITERATOR_LOOP = 0b0100_0000;
         const FOR_AWAIT_OF_LOOP = 0b1000_0000;
@@ -41,6 +124,10 @@ bitflags! {
         ///
         /// This bitflag is inherited if the previous [`JumpControlInfo`].
         const USE_EXPR = 0b0001_0000_0000;
+
+        const IN_FINALLY = 0b0010_0000_0000;
+
+        const FINALLY = 0b0100_0000_0000;
     }
 }
 
@@ -50,21 +137,19 @@ impl Default for JumpControlInfoFlags {
     }
 }
 
-impl Default for JumpControlInfo {
-    fn default() -> Self {
+/// ---- `JumpControlInfo` Creation Methods ----
+impl JumpControlInfo {
+    fn new(current_open_environments_count: u32) -> Self {
         Self {
             label: None,
             start_address: u32::MAX,
             flags: JumpControlInfoFlags::default(),
-            set_jumps: Vec::new(),
-            breaks: Vec::new(),
-            try_continues: Vec::new(),
+            jumps: Vec::new(),
+            current_open_environments_count,
+            handler_index: None,
         }
     }
-}
 
-/// ---- `JumpControlInfo` Creation Methods ----
-impl JumpControlInfo {
     pub(crate) const fn with_label(mut self, label: Option<Sym>) -> Self {
         self.label = label;
         self
@@ -138,14 +223,14 @@ impl JumpControlInfo {
         self.flags.contains(JumpControlInfoFlags::LABELLED)
     }
 
-    pub(crate) const fn in_finally(&self) -> bool {
-        self.flags.contains(JumpControlInfoFlags::IN_FINALLY)
-    }
-
     pub(crate) const fn has_finally(&self) -> bool {
         self.flags.contains(JumpControlInfoFlags::HAS_FINALLY)
     }
 
+    pub(crate) const fn in_finally(&self) -> bool {
+        self.flags.contains(JumpControlInfoFlags::IN_FINALLY)
+    }
+
     pub(crate) const fn use_expr(&self) -> bool {
         self.flags.contains(JumpControlInfoFlags::USE_EXPR)
     }
@@ -157,6 +242,10 @@ impl JumpControlInfo {
     pub(crate) const fn for_await_of_loop(&self) -> bool {
         self.flags.contains(JumpControlInfoFlags::FOR_AWAIT_OF_LOOP)
     }
+
+    pub(crate) const fn finally(&self) -> bool {
+        self.flags.contains(JumpControlInfoFlags::FINALLY)
+    }
 }
 
 /// ---- `JumpControlInfo` interaction methods ----
@@ -171,25 +260,6 @@ impl JumpControlInfo {
     pub(crate) fn set_start_address(&mut self, start_address: u32) {
         self.start_address = start_address;
     }
-
-    /// Set the `in_finally` field of `JumpControlInfo`.
-    pub(crate) fn set_in_finally(&mut self, value: bool) {
-        self.flags.set(JumpControlInfoFlags::IN_FINALLY, value);
-    }
-
-    /// Pushes a `Label` onto the `break` vector of `JumpControlInfo`.
-    pub(crate) fn push_break_label(&mut self, break_label: Label) {
-        self.breaks.push(break_label);
-    }
-
-    /// Pushes a `Label` onto the `try_continues` vector of `JumpControlInfo`.
-    pub(crate) fn push_try_continue_label(&mut self, try_continue_label: Label) {
-        self.try_continues.push(try_continue_label);
-    }
-
-    pub(crate) fn push_set_jumps(&mut self, set_jump_label: Label) {
-        self.set_jumps.push(set_jump_label);
-    }
 }
 
 // `JumpControlInfo` related methods that are implemented on `ByteCompiler`.
@@ -198,7 +268,8 @@ impl ByteCompiler<'_, '_> {
     ///
     /// Default `JumpControlInfoKind` is `JumpControlInfoKind::Loop`
     pub(crate) fn push_empty_loop_jump_control(&mut self, use_expr: bool) {
-        let new_info = JumpControlInfo::default().with_loop_flag(true);
+        let new_info =
+            JumpControlInfo::new(self.current_open_environments_count).with_loop_flag(true);
         self.push_contol_info(new_info, use_expr);
     }
 
@@ -206,11 +277,6 @@ impl ByteCompiler<'_, '_> {
         self.jump_info.last_mut()
     }
 
-    pub(crate) fn set_jump_control_start_address(&mut self, start_address: u32) {
-        let info = self.jump_info.last_mut().expect("jump_info must exist");
-        info.set_start_address(start_address);
-    }
-
     pub(crate) fn push_contol_info(&mut self, mut info: JumpControlInfo, use_expr: bool) {
         info.flags.set(JumpControlInfoFlags::USE_EXPR, use_expr);
 
@@ -219,9 +285,44 @@ impl ByteCompiler<'_, '_> {
             info.flags |= last.flags & JumpControlInfoFlags::USE_EXPR;
         }
 
+        if info.is_try_block() || info.finally() {
+            info.handler_index = Some(self.push_handler());
+        }
+
         self.jump_info.push(info);
     }
 
+    pub(crate) fn push_handler(&mut self) -> u32 {
+        let handler_index = self.handlers.len() as u32;
+        let start_address = self.next_opcode_location();
+
+        // FIXME(HalidOdat): figure out value stack fp value.
+        let env_fp = self.current_open_environments_count;
+        self.handlers.push(Handler {
+            range: (start_address..u32::MAX),
+            handler: 0,
+            fp: 0,
+            env_fp,
+        });
+
+        handler_index
+    }
+
+    pub(crate) fn patch_handler(&mut self, end_address: u32, handler_address: u32) {
+        let info = self
+            .jump_info
+            .last_mut()
+            .expect("There should be a try jump info");
+        assert!(info.is_try_block() || info.finally());
+
+        let handler_index = info
+            .handler_index
+            .expect("try jump info must have handler index");
+
+        self.handlers[handler_index as usize].range.end = end_address;
+        self.handlers[handler_index as usize].handler = handler_address;
+    }
+
     /// Does the jump control info have the `use_expr` flag set to true.
     ///
     /// See [`JumpControlInfoFlags`].
@@ -242,7 +343,7 @@ impl ByteCompiler<'_, '_> {
         start_address: u32,
         use_expr: bool,
     ) {
-        let new_info = JumpControlInfo::default()
+        let new_info = JumpControlInfo::new(self.current_open_environments_count)
             .with_labelled_block_flag(true)
             .with_label(Some(label))
             .with_start_address(start_address);
@@ -260,13 +361,11 @@ impl ByteCompiler<'_, '_> {
         let info = self.jump_info.pop().expect("no jump information found");
 
         assert!(info.is_labelled());
+        assert!(info.label().is_some());
 
-        for label in info.breaks {
-            self.patch_jump(label);
-        }
-
-        for label in info.try_continues {
-            self.patch_jump_with_target(label, info.start_address);
+        let start_address = info.start_address();
+        for jump_record in info.jumps {
+            jump_record.perform_actions(start_address, self);
         }
     }
     // ---- `IterationStatement`'s `JumpControlInfo` methods ---- //
@@ -278,7 +377,7 @@ impl ByteCompiler<'_, '_> {
         start_address: u32,
         use_expr: bool,
     ) {
-        let new_info = JumpControlInfo::default()
+        let new_info = JumpControlInfo::new(self.current_open_environments_count)
             .with_loop_flag(true)
             .with_label(label)
             .with_start_address(start_address);
@@ -293,7 +392,7 @@ impl ByteCompiler<'_, '_> {
         start_address: u32,
         use_expr: bool,
     ) {
-        let new_info = JumpControlInfo::default()
+        let new_info = JumpControlInfo::new(self.current_open_environments_count)
             .with_loop_flag(true)
             .with_label(label)
             .with_start_address(start_address)
@@ -308,7 +407,7 @@ impl ByteCompiler<'_, '_> {
         start_address: u32,
         use_expr: bool,
     ) {
-        let new_info = JumpControlInfo::default()
+        let new_info = JumpControlInfo::new(self.current_open_environments_count)
             .with_loop_flag(true)
             .with_label(label)
             .with_start_address(start_address)
@@ -330,12 +429,8 @@ impl ByteCompiler<'_, '_> {
         assert!(info.is_loop());
 
         let start_address = info.start_address();
-        for label in info.try_continues {
-            self.patch_jump_with_target(label, start_address);
-        }
-
-        for label in info.breaks {
-            self.patch_jump(label);
+        for jump_record in info.jumps {
+            jump_record.perform_actions(start_address, self);
         }
     }
 
@@ -348,7 +443,7 @@ impl ByteCompiler<'_, '_> {
         start_address: u32,
         use_expr: bool,
     ) {
-        let new_info = JumpControlInfo::default()
+        let new_info = JumpControlInfo::new(self.current_open_environments_count)
             .with_switch_flag(true)
             .with_label(label)
             .with_start_address(start_address);
@@ -367,8 +462,9 @@ impl ByteCompiler<'_, '_> {
 
         assert!(info.is_switch());
 
-        for label in info.breaks {
-            self.patch_jump(label);
+        let start_address = info.start_address();
+        for jump_record in info.jumps {
+            jump_record.perform_actions(start_address, self);
         }
     }
 
@@ -381,7 +477,7 @@ impl ByteCompiler<'_, '_> {
         start_address: u32,
         use_expr: bool,
     ) {
-        let new_info = JumpControlInfo::default()
+        let new_info = JumpControlInfo::new(self.current_open_environments_count)
             .with_try_block_flag(true)
             .with_start_address(start_address)
             .with_has_finally(has_finally);
@@ -389,6 +485,15 @@ impl ByteCompiler<'_, '_> {
         self.push_contol_info(new_info, use_expr);
     }
 
+    pub(crate) fn push_finally_control_info(&mut self, start_address: u32, use_expr: bool) {
+        let mut new_info = JumpControlInfo::new(self.current_open_environments_count)
+            .with_start_address(start_address);
+
+        new_info.flags |= JumpControlInfoFlags::FINALLY;
+
+        self.push_contol_info(new_info, use_expr);
+    }
+
     /// Pops and handles the info for a try block's `JumpControlInfo`
     ///
     /// # Panic
@@ -396,74 +501,54 @@ impl ByteCompiler<'_, '_> {
     ///  - Will panic if popped `JumpControlInfo` is not for a try block.
     pub(crate) fn pop_try_control_info(&mut self, try_end: u32) {
         assert!(!self.jump_info.is_empty());
-        let mut info = self.jump_info.pop().expect("no jump information found");
+        let info = self.jump_info.pop().expect("no jump information found");
 
         assert!(info.is_try_block());
 
         // Handle breaks. If there is a finally, breaks should go to the finally
         if info.has_finally() {
-            for label in info.breaks {
-                self.patch_jump_with_target(label, try_end);
-            }
-        } else {
-            // When there is no finally, search for the break point.
-            for jump_info in self.jump_info.iter_mut().rev() {
-                if !jump_info.is_labelled() {
-                    jump_info.breaks.append(&mut info.breaks);
-                    break;
-                }
+            if info.jumps.is_empty() {
+                return;
             }
-        }
 
-        // Handle set_jumps
-        for label in info.set_jumps {
-            for jump_info in self.jump_info.iter_mut().rev() {
-                if jump_info.is_loop() || jump_info.is_switch() {
-                    jump_info.breaks.push(label);
-                    break;
-                }
+            for JumpRecord { label, .. } in &info.jumps {
+                self.patch_jump_with_target(*label, try_end);
             }
-        }
 
-        // Pass continues down the stack.
-        if let Some(jump_info) = self.jump_info.last_mut() {
-            jump_info.try_continues.append(&mut info.try_continues);
-        }
-    }
+            let (jumps, default) = self.jump_table(info.jumps.len() as u32);
 
-    /// Pushes a `TryStatement`'s Finally block `JumpControlInfo` onto the `jump_info` stack.
-    pub(crate) fn push_init_finally_control_info(&mut self, use_expr: bool) {
-        let mut new_info = JumpControlInfo::default().with_try_block_flag(true);
+            // Handle breaks/continue/returns in a finally block
+            for (i, label) in jumps.iter().enumerate() {
+                self.patch_jump(*label);
 
-        new_info.set_in_finally(true);
+                let jump_record = info.jumps[i].clone();
+                jump_record.perform_actions(label.index, self);
+            }
 
-        self.push_contol_info(new_info, use_expr);
+            self.patch_jump(default);
+        } else {
+            for jump in info.jumps {
+                // NOTE: There shouldn't be any breaks or continues attched on a try block without finally
+                assert_eq!(jump.kind, JumpRecordKind::Return);
+            }
+        }
     }
 
     pub(crate) fn pop_finally_control_info(&mut self) {
         assert!(!self.jump_info.is_empty());
-        let mut info = self.jump_info.pop().expect("no jump information found");
+        let info = self.jump_info.pop().expect("no jump information found");
 
-        assert!(info.in_finally());
+        assert!(info.finally());
 
-        // Handle set_jumps
-        for label in info.set_jumps {
-            for jump_info in self.jump_info.iter_mut().rev() {
-                if jump_info.is_loop() || jump_info.is_switch() {
-                    jump_info.breaks.push(label);
-                    break;
-                }
-            }
-        }
+        assert!(info.jumps.is_empty());
+    }
 
-        // Handle breaks in a finally block
-        for label in info.breaks {
-            self.patch_jump(label);
+    pub(crate) fn jump_info_open_environment_count(&self, index: usize) -> u32 {
+        let current = &self.jump_info[index];
+        if let Some(next) = self.jump_info.get(index + 1) {
+            return next.current_open_environments_count - current.current_open_environments_count;
         }
 
-        // Pass continues down the stack.
-        if let Some(jump_info) = self.jump_info.last_mut() {
-            jump_info.try_continues.append(&mut info.try_continues);
-        }
+        self.current_open_environments_count - current.current_open_environments_count
     }
 }
diff --git a/boa_engine/src/bytecompiler/mod.rs b/boa_engine/src/bytecompiler/mod.rs
index 927a9407385..208fd9eec64 100644
--- a/boa_engine/src/bytecompiler/mod.rs
+++ b/boa_engine/src/bytecompiler/mod.rs
@@ -17,7 +17,7 @@ use crate::{
     builtins::function::ThisMode,
     environments::{BindingLocator, BindingLocatorError, CompileTimeEnvironment},
     js_string,
-    vm::{BindingOpcode, CodeBlock, CodeBlockFlags, Opcode},
+    vm::{BindingOpcode, CodeBlock, CodeBlockFlags, Handler, Opcode},
     Context, JsBigInt, JsString, JsValue,
 };
 use boa_ast::{
@@ -41,6 +41,7 @@ use rustc_hash::FxHashMap;
 
 pub(crate) use function::FunctionCompiler;
 pub(crate) use jump_control::JumpControlInfo;
+use thin_vec::ThinVec;
 
 /// Describes how a node has been defined in the source code.
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -246,8 +247,14 @@ pub struct ByteCompiler<'ctx, 'host> {
     /// The environment that is currently active.
     pub(crate) current_environment: Rc<CompileTimeEnvironment>,
 
+    pub(crate) current_open_environments_count: u32,
+
+    pub(crate) returns_to_patch: Vec<Label>,
+
     pub(crate) code_block_flags: CodeBlockFlags,
 
+    pub(crate) handlers: ThinVec<Handler>,
+
     literals_map: FxHashMap<Literal, u32>,
     names_map: FxHashMap<Identifier, u32>,
     bindings_map: FxHashMap<BindingLocator, u32>,
@@ -290,7 +297,10 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
             this_mode: ThisMode::Global,
             params: FormalParameterList::default(),
             compile_environments: Vec::default(),
+            current_open_environments_count: 0,
+            returns_to_patch: Vec::default(),
             code_block_flags,
+            handlers: ThinVec::default(),
 
             literals_map: FxHashMap::default(),
             names_map: FxHashMap::default(),
@@ -503,6 +513,21 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
         self.emit_opcode_with_operand(Opcode::JumpIfNullOrUndefined)
     }
 
+    fn jump_table(&mut self, count: u32) -> (Vec<Label>, Label) {
+        let index = self.next_opcode_location();
+        self.emit(Opcode::JumpTable, &[count, Self::DUMMY_ADDRESS]);
+        let default = Label { index: index + 4 };
+        let mut labels = Vec::with_capacity(count as usize);
+        for i in 0..count {
+            labels.push(Label {
+                index: index + 8 + 4 * i,
+            });
+            self.emit_u32(Self::DUMMY_ADDRESS);
+        }
+
+        (labels, default)
+    }
+
     /// Emit an opcode with a dummy operand.
     /// Return the `Label` of the operand.
     pub(crate) fn emit_opcode_with_operand(&mut self, opcode: Opcode) -> Label {
@@ -1386,13 +1411,18 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
     #[inline]
     #[must_use]
     #[allow(clippy::missing_const_for_fn)]
-    pub fn finish(self) -> CodeBlock {
+    pub fn finish(mut self) -> CodeBlock {
+        for ret in self.returns_to_patch.clone() {
+            self.patch_jump(ret);
+        }
+
         let name = self
             .context
             .interner()
             .resolve_expect(self.function_name)
             .utf16()
             .into();
+
         CodeBlock {
             name,
             length: self.length,
@@ -1404,6 +1434,7 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
             bindings: self.bindings.into_boxed_slice(),
             functions: self.functions.into_boxed_slice(),
             compile_environments: self.compile_environments.into_boxed_slice(),
+            handlers: self.handlers,
             flags: Cell::new(self.code_block_flags),
         }
     }
diff --git a/boa_engine/src/bytecompiler/statement/break.rs b/boa_engine/src/bytecompiler/statement/break.rs
index eb51b429cd5..7a349e66682 100644
--- a/boa_engine/src/bytecompiler/statement/break.rs
+++ b/boa_engine/src/bytecompiler/statement/break.rs
@@ -1,73 +1,73 @@
-use crate::{
-    bytecompiler::{ByteCompiler, JumpControlInfo},
-    vm::Opcode,
+use crate::bytecompiler::{
+    jump_control::{JumpRecord, JumpRecordAction, JumpRecordKind},
+    ByteCompiler,
 };
 use boa_ast::statement::Break;
-use boa_interner::Sym;
 
 impl ByteCompiler<'_, '_> {
     /// Compile a [`Break`] `boa_ast` node
     pub(crate) fn compile_break(&mut self, node: Break, _use_expr: bool) {
-        if let Some(info) = self.jump_info.last().filter(|info| info.is_try_block()) {
-            let has_finally_or_is_finally = info.has_finally() || info.in_finally();
+        let actions = self.break_jump_record_actions(node);
 
-            let (break_label, target_jump_label) =
-                self.emit_opcode_with_two_operands(Opcode::Break);
+        JumpRecord::new(JumpRecordKind::Break, Self::DUMMY_LABEL, actions)
+            .perform_actions(u32::MAX, self);
+    }
 
-            if let Some(node_label) = node.label() {
-                let info = self.jump_info_label(node_label);
-                info.push_break_label(target_jump_label);
+    fn break_jump_record_actions(&self, node: Break) -> Vec<JumpRecordAction> {
+        let mut actions = Vec::default();
 
-                if !has_finally_or_is_finally {
-                    info.push_break_label(break_label);
-                    return;
-                }
-            } else {
-                self.jump_info
-                    .last_mut()
-                    .expect("jump_info must exist to reach this point")
-                    .push_set_jumps(target_jump_label);
-            }
+        if let Some(label) = node.label() {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                let count = self.jump_info_open_environment_count(i);
+                actions.push(JumpRecordAction::PopEnvironments { count });
 
-            let info = self
-                .jump_info
-                .last_mut()
-                .expect("This try block must exist");
+                if info.is_try_block() && info.has_finally() && !info.in_finally() {
+                    let next_index = info.jumps.len();
 
-            info.push_break_label(break_label);
+                    actions.push(JumpRecordAction::HandleFinally {
+                        value: next_index as i32 + 1,
+                    });
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
+                }
 
-            return;
-        }
+                if info.label() == Some(label) {
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
+                    break;
+                }
 
-        // Emit the break opcode -> (Label, Label)
-        let (break_label, target_label) = self.emit_opcode_with_two_operands(Opcode::Break);
-        if let Some(label) = node.label() {
-            let info = self.jump_info_label(label);
-            info.push_break_label(break_label);
-            info.push_break_label(target_label);
-            return;
-        }
+                if info.iterator_loop() {
+                    actions.push(JumpRecordAction::CloseIterator {
+                        r#async: info.for_await_of_loop(),
+                    });
+                }
+            }
+        } else {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                let count = self.jump_info_open_environment_count(i);
+                actions.push(JumpRecordAction::PopEnvironments { count });
 
-        let info = self.jump_info_non_labelled();
-        info.push_break_label(break_label);
-        info.push_break_label(target_label);
-    }
+                if info.is_try_block() && info.has_finally() && !info.in_finally() {
+                    let next_index = info.jumps.len();
 
-    fn jump_info_non_labelled(&mut self) -> &mut JumpControlInfo {
-        for info in self.jump_info.iter_mut().rev() {
-            if !info.is_labelled() {
-                return info;
-            }
-        }
-        panic!("Jump info without label must exist");
-    }
+                    actions.push(JumpRecordAction::HandleFinally {
+                        value: next_index as i32 + 1,
+                    });
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
+                }
 
-    fn jump_info_label(&mut self, label: Sym) -> &mut JumpControlInfo {
-        for info in self.jump_info.iter_mut().rev() {
-            if info.label() == Some(label) {
-                return info;
+                if info.is_loop() || info.is_switch() {
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
+                    break;
+                }
             }
         }
-        panic!("Jump info with label must exist");
+
+        actions.reverse();
+
+        actions
     }
 }
diff --git a/boa_engine/src/bytecompiler/statement/continue.rs b/boa_engine/src/bytecompiler/statement/continue.rs
index e6f68e9c5d0..d32d45d0d51 100644
--- a/boa_engine/src/bytecompiler/statement/continue.rs
+++ b/boa_engine/src/bytecompiler/statement/continue.rs
@@ -1,118 +1,79 @@
-use crate::{bytecompiler::ByteCompiler, vm::Opcode};
+use crate::bytecompiler::{
+    jump_control::{JumpRecord, JumpRecordAction, JumpRecordKind},
+    ByteCompiler,
+};
 use boa_ast::statement::Continue;
 
 impl ByteCompiler<'_, '_> {
     #[allow(clippy::unnecessary_wraps)]
     pub(crate) fn compile_continue(&mut self, node: Continue, _use_expr: bool) {
-        if let Some(info) = self.jump_info.last().filter(|info| info.is_try_block()) {
-            let in_finally = info.in_finally();
-            let in_finally_or_has_finally = in_finally || info.has_finally();
+        let actions = self.continue_jump_record_actions(node);
 
-            // 1. Handle if node has a label.
-            if let Some(node_label) = node.label() {
-                let items = self.jump_info.iter().rev().filter(|info| info.is_loop());
-                let mut iterator_closes = Vec::new();
-
-                for info in items {
-                    if info.label() == Some(node_label) {
-                        break;
-                    }
+        JumpRecord::new(JumpRecordKind::Continue, Self::DUMMY_LABEL, actions)
+            .perform_actions(u32::MAX, self);
+    }
 
-                    if info.iterator_loop() {
-                        iterator_closes.push(info.for_await_of_loop());
-                    }
-                }
+    fn continue_jump_record_actions(&self, node: Continue) -> Vec<JumpRecordAction> {
+        let mut actions = Vec::default();
 
-                for r#async in iterator_closes {
-                    self.iterator_close(r#async);
-                }
+        if let Some(label) = node.label() {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                let count = self.jump_info_open_environment_count(i);
+                actions.push(JumpRecordAction::PopEnvironments { count });
 
-                let (cont_label, set_label) = self.emit_opcode_with_two_operands(Opcode::Continue);
+                if info.is_try_block() && info.has_finally() && !info.in_finally() {
+                    let next_index = info.jumps.len();
 
-                let loops = self
-                    .jump_info
-                    .iter_mut()
-                    .rev()
-                    .filter(|info| info.is_loop());
-                let mut set_continue_as_break = false;
-                for info in loops {
-                    let found_label = info.label() == Some(node_label);
-                    if found_label && in_finally_or_has_finally {
-                        set_continue_as_break = true;
-                        info.push_try_continue_label(set_label);
-                        break;
-                    } else if found_label && !in_finally_or_has_finally {
-                        info.push_try_continue_label(cont_label);
-                        info.push_try_continue_label(set_label);
-                        break;
-                    }
+                    actions.push(JumpRecordAction::HandleFinally {
+                        value: next_index as i32 + 1,
+                    });
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
                 }
-                if set_continue_as_break {
-                    self.jump_info
-                        .last_mut()
-                        .expect("no jump information found")
-                        .push_break_label(cont_label);
-                }
-            } else {
-                // TODO: Add has finally or in finally here
-                let (cont_label, set_label) = self.emit_opcode_with_two_operands(Opcode::Continue);
-                if in_finally_or_has_finally {
-                    self.jump_info
-                        .last_mut()
-                        .expect("Must exist and be a try block")
-                        .push_break_label(cont_label);
-                };
-                let mut items = self
-                    .jump_info
-                    .iter_mut()
-                    .rev()
-                    .filter(|info| info.is_loop());
-                let jump_info = items.next().expect("continue must be inside loop");
-                if !in_finally_or_has_finally {
-                    jump_info.push_try_continue_label(cont_label);
-                };
-                jump_info.push_try_continue_label(set_label);
-            };
-        } else if let Some(node_label) = node.label() {
-            let items = self.jump_info.iter().rev().filter(|info| info.is_loop());
-            let mut iterator_closes = Vec::new();
-            for info in items {
-                if info.label() == Some(node_label) {
+
+                if info.label() == Some(label) {
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
                     break;
                 }
 
                 if info.iterator_loop() {
-                    iterator_closes.push(info.for_await_of_loop());
+                    actions.push(JumpRecordAction::CloseIterator {
+                        r#async: info.for_await_of_loop(),
+                    });
                 }
             }
+        } else {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                let count = self.jump_info_open_environment_count(i);
+                actions.push(JumpRecordAction::PopEnvironments { count });
 
-            for r#async in iterator_closes {
-                self.iterator_close(r#async);
-            }
+                if info.is_try_block() && info.has_finally() && !info.in_finally() {
+                    let next_index = info.jumps.len();
 
-            let (cont_label, set_label) = self.emit_opcode_with_two_operands(Opcode::Continue);
-            let loops = self
-                .jump_info
-                .iter_mut()
-                .rev()
-                .filter(|info| info.is_loop());
+                    actions.push(JumpRecordAction::HandleFinally {
+                        value: next_index as i32 + 1,
+                    });
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
+                }
+
+                if info.is_loop() {
+                    actions.push(JumpRecordAction::CreateJump);
+                    actions.push(JumpRecordAction::Transfter { index: i as u32 });
+                    break;
+                }
 
-            for info in loops {
-                if info.label() == Some(node_label) {
-                    info.push_try_continue_label(cont_label);
-                    info.push_try_continue_label(set_label);
+                if info.iterator_loop() {
+                    actions.push(JumpRecordAction::CloseIterator {
+                        r#async: info.for_await_of_loop(),
+                    });
                 }
             }
-        } else {
-            let (cont_label, set_label) = self.emit_opcode_with_two_operands(Opcode::Continue);
-            let mut items = self
-                .jump_info
-                .iter_mut()
-                .rev()
-                .filter(|info| info.is_loop());
-            let jump_info = items.next().expect("continue must be inside loop");
-            jump_info.push_try_continue_label(cont_label);
-            jump_info.push_try_continue_label(set_label);
         }
+
+        actions.reverse();
+
+        actions
     }
 }
diff --git a/boa_engine/src/bytecompiler/statement/labelled.rs b/boa_engine/src/bytecompiler/statement/labelled.rs
index 8ae56121872..860a13b4ac0 100644
--- a/boa_engine/src/bytecompiler/statement/labelled.rs
+++ b/boa_engine/src/bytecompiler/statement/labelled.rs
@@ -1,7 +1,4 @@
-use crate::{
-    bytecompiler::{ByteCompiler, NodeKind},
-    vm::Opcode,
-};
+use crate::bytecompiler::{ByteCompiler, NodeKind};
 use boa_ast::{
     statement::{Labelled, LabelledItem},
     Statement,
@@ -11,7 +8,6 @@ impl ByteCompiler<'_, '_> {
     /// Compile a [`Labelled`] `boa_ast` node
     pub(crate) fn compile_labelled(&mut self, labelled: &Labelled, use_expr: bool) {
         let labelled_loc = self.next_opcode_location();
-        let end_label = self.emit_opcode_with_operand(Opcode::LabelledStart);
         self.push_labelled_control_info(labelled.label(), labelled_loc, use_expr);
 
         match labelled.item() {
@@ -38,9 +34,6 @@ impl ByteCompiler<'_, '_> {
             }
         }
 
-        let labelled_end = self.next_opcode_location();
-        self.patch_jump_with_target(end_label, labelled_end);
         self.pop_labelled_control_info();
-        self.emit_opcode(Opcode::LabelledEnd);
     }
 }
diff --git a/boa_engine/src/bytecompiler/statement/loop.rs b/boa_engine/src/bytecompiler/statement/loop.rs
index e0b659041aa..7438db829ec 100644
--- a/boa_engine/src/bytecompiler/statement/loop.rs
+++ b/boa_engine/src/bytecompiler/statement/loop.rs
@@ -57,7 +57,6 @@ impl ByteCompiler<'_, '_> {
         }
 
         self.push_empty_loop_jump_control(use_expr);
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
         let initial_jump = self.jump();
         let start_address = self.next_opcode_location();
 
@@ -81,7 +80,6 @@ impl ByteCompiler<'_, '_> {
         }
 
         self.emit_opcode(Opcode::LoopContinue);
-        self.patch_jump_with_target(loop_start, start_address);
 
         if let Some(final_expr) = for_loop.final_expr() {
             self.compile_expr(final_expr, false);
@@ -101,9 +99,10 @@ impl ByteCompiler<'_, '_> {
         self.emit(Opcode::Jump, &[start_address]);
 
         self.patch_jump(exit);
-        self.patch_jump(loop_exit);
         self.pop_loop_control_info();
-        self.emit_opcode(Opcode::LoopEnd);
+        if env_labels.is_some() {
+            self.emit_opcode(Opcode::PopEnvironment);
+        }
 
         if let Some(env_labels) = env_labels {
             let env_index = self.pop_compile_environment();
@@ -111,7 +110,6 @@ impl ByteCompiler<'_, '_> {
             if let Some(iteration_env_labels) = iteration_env_labels {
                 self.patch_jump_with_target(iteration_env_labels, env_index);
             }
-            self.emit_opcode(Opcode::PopEnvironment);
         }
     }
 
@@ -154,12 +152,9 @@ impl ByteCompiler<'_, '_> {
         let early_exit = self.jump_if_null_or_undefined();
         self.emit_opcode(Opcode::CreateForInIterator);
 
-        let (loop_start, exit_label) =
-            self.emit_opcode_with_two_operands(Opcode::IteratorLoopStart);
         let start_address = self.next_opcode_location();
         self.push_loop_control_info_for_of_in_loop(label, start_address, use_expr);
         self.emit_opcode(Opcode::LoopContinue);
-        self.patch_jump_with_target(loop_start, start_address);
 
         self.emit_opcode(Opcode::IteratorNext);
         self.emit_opcode(Opcode::IteratorDone);
@@ -233,9 +228,7 @@ impl ByteCompiler<'_, '_> {
         self.emit(Opcode::Jump, &[start_address]);
 
         self.patch_jump(exit);
-        self.patch_jump(exit_label);
         self.pop_loop_control_info();
-        self.emit_opcode(Opcode::LoopEnd);
 
         self.iterator_close(false);
 
@@ -278,7 +271,6 @@ impl ByteCompiler<'_, '_> {
             self.emit_opcode(Opcode::GetIterator);
         }
 
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::IteratorLoopStart);
         let start_address = self.next_opcode_location();
         if for_of_loop.r#await() {
             self.push_loop_control_info_for_await_of_loop(label, start_address, use_expr);
@@ -286,7 +278,6 @@ impl ByteCompiler<'_, '_> {
             self.push_loop_control_info_for_of_in_loop(label, start_address, use_expr);
         }
         self.emit_opcode(Opcode::LoopContinue);
-        self.patch_jump_with_target(loop_start, start_address);
 
         self.emit_opcode(Opcode::IteratorNext);
         if for_of_loop.r#await() {
@@ -306,6 +297,7 @@ impl ByteCompiler<'_, '_> {
             Some(self.emit_opcode_with_operand(Opcode::PushDeclarativeEnvironment))
         };
 
+        let mut handler_index = None;
         match for_of_loop.initializer() {
             IterableLoopInitializer::Identifier(ref ident) => {
                 match self.set_mutable_binding(*ident) {
@@ -323,6 +315,7 @@ impl ByteCompiler<'_, '_> {
                 }
             }
             IterableLoopInitializer::Access(access) => {
+                handler_index = Some(self.push_handler());
                 self.access_set(
                     Access::Property { access },
                     false,
@@ -366,10 +359,39 @@ impl ByteCompiler<'_, '_> {
                 }
             },
             IterableLoopInitializer::Pattern(pattern) => {
+                handler_index = Some(self.push_handler());
                 self.compile_declaration_pattern(pattern, BindingOpcode::SetName);
             }
         }
 
+        // If the left-hand side is not a lexical binding and the assignment produces
+        // an error, the iterator should be closed and the error forwarded to the
+        // runtime.
+        if let Some(handler_index) = handler_index {
+            let end_address = self.next_opcode_location();
+
+            let exit = self.jump();
+            let handler_address = self.next_opcode_location();
+
+            self.emit_opcode(Opcode::Exception);
+
+            // NOTE: Capture throw of the iterator close and ignore it.
+            {
+                let handler_index = self.push_handler();
+                self.iterator_close(for_of_loop.r#await());
+                let end_address = self.next_opcode_location();
+                self.handlers[handler_index as usize].handler = end_address;
+                self.handlers[handler_index as usize].range.end = end_address;
+            }
+
+            let handler_index = handler_index as usize;
+            self.handlers[handler_index].handler = handler_address;
+            self.handlers[handler_index].range.end = end_address;
+
+            self.emit_opcode(Opcode::Throw);
+            self.patch_jump(exit);
+        }
+
         self.compile_stmt(for_of_loop.body(), use_expr, true);
 
         if let Some(iteration_environment) = iteration_environment {
@@ -381,9 +403,7 @@ impl ByteCompiler<'_, '_> {
         self.emit(Opcode::Jump, &[start_address]);
 
         self.patch_jump(exit);
-        self.patch_jump(loop_exit);
         self.pop_loop_control_info();
-        self.emit_opcode(Opcode::LoopEnd);
 
         self.iterator_close(for_of_loop.r#await());
     }
@@ -394,11 +414,9 @@ impl ByteCompiler<'_, '_> {
         label: Option<Sym>,
         use_expr: bool,
     ) {
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
         let start_address = self.next_opcode_location();
         self.emit_opcode(Opcode::LoopContinue);
         self.push_loop_control_info(label, start_address, use_expr);
-        self.patch_jump_with_target(loop_start, start_address);
 
         self.compile_expr(while_loop.condition(), true);
         let exit = self.jump_if_false();
@@ -408,9 +426,7 @@ impl ByteCompiler<'_, '_> {
         self.emit(Opcode::Jump, &[start_address]);
 
         self.patch_jump(exit);
-        self.patch_jump(loop_exit);
         self.pop_loop_control_info();
-        self.emit_opcode(Opcode::LoopEnd);
     }
 
     pub(crate) fn compile_do_while_loop(
@@ -419,12 +435,10 @@ impl ByteCompiler<'_, '_> {
         label: Option<Sym>,
         use_expr: bool,
     ) {
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
         let initial_label = self.jump();
 
         let start_address = self.next_opcode_location();
 
-        self.patch_jump_with_target(loop_start, start_address);
         self.push_loop_control_info(label, start_address, use_expr);
 
         let condition_label_address = self.next_opcode_location();
@@ -438,9 +452,7 @@ impl ByteCompiler<'_, '_> {
 
         self.emit(Opcode::Jump, &[condition_label_address]);
         self.patch_jump(exit);
-        self.patch_jump(loop_exit);
 
         self.pop_loop_control_info();
-        self.emit_opcode(Opcode::LoopEnd);
     }
 }
diff --git a/boa_engine/src/bytecompiler/statement/mod.rs b/boa_engine/src/bytecompiler/statement/mod.rs
index c9c3ea6fc86..cc68339e435 100644
--- a/boa_engine/src/bytecompiler/statement/mod.rs
+++ b/boa_engine/src/bytecompiler/statement/mod.rs
@@ -2,6 +2,8 @@ use crate::{bytecompiler::ByteCompiler, vm::Opcode};
 
 use boa_ast::Statement;
 
+use super::jump_control::{JumpRecord, JumpRecordAction, JumpRecordKind};
+
 mod block;
 mod r#break;
 mod r#continue;
@@ -71,6 +73,14 @@ impl ByteCompiler<'_, '_> {
                     self.emit_opcode(Opcode::PushUndefined);
                 }
                 self.emit_opcode(Opcode::SetReturnValue);
+
+                // if !self.in_async_generator {
+                let actions = self.return_jump_record_actions();
+
+                JumpRecord::new(JumpRecordKind::Return, Self::DUMMY_LABEL, actions)
+                    .perform_actions(u32::MAX, self);
+                // }
+
                 self.emit_opcode(Opcode::Return);
             }
             Statement::Try(t) => self.compile_try(t, use_expr),
@@ -84,4 +94,33 @@ impl ByteCompiler<'_, '_> {
             Statement::Empty => {}
         }
     }
+
+    fn return_jump_record_actions(&self) -> Vec<JumpRecordAction> {
+        let mut actions = Vec::default();
+
+        for (i, info) in self.jump_info.iter().enumerate().rev() {
+            let count = self.jump_info_open_environment_count(i);
+            actions.push(JumpRecordAction::PopEnvironments { count });
+
+            if info.is_try_block() && info.has_finally() && !info.in_finally() {
+                let next_index = info.jumps.len();
+
+                actions.push(JumpRecordAction::HandleFinally {
+                    value: next_index as i32 + 1,
+                });
+                actions.push(JumpRecordAction::CreateJump);
+                actions.push(JumpRecordAction::Transfter { index: i as u32 });
+            }
+
+            if info.iterator_loop() {
+                actions.push(JumpRecordAction::CloseIterator {
+                    r#async: info.for_await_of_loop(),
+                });
+            }
+        }
+
+        actions.reverse();
+
+        actions
+    }
 }
diff --git a/boa_engine/src/bytecompiler/statement/switch.rs b/boa_engine/src/bytecompiler/statement/switch.rs
index 55eae910337..46df6c692f9 100644
--- a/boa_engine/src/bytecompiler/statement/switch.rs
+++ b/boa_engine/src/bytecompiler/statement/switch.rs
@@ -11,11 +11,8 @@ impl ByteCompiler<'_, '_> {
 
         self.block_declaration_instantiation(switch);
 
-        let (start_label, end_label) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
-
         let start_address = self.next_opcode_location();
         self.push_switch_control_info(None, start_address, use_expr);
-        self.patch_jump_with_target(start_label, start_address);
 
         let mut labels = Vec::with_capacity(switch.cases().len());
         for case in switch.cases() {
@@ -52,8 +49,6 @@ impl ByteCompiler<'_, '_> {
         }
 
         self.pop_switch_control_info();
-        self.patch_jump(end_label);
-        self.emit_opcode(Opcode::LoopEnd);
 
         let env_index = self.pop_compile_environment();
         self.patch_jump_with_target(push_env, env_index);
diff --git a/boa_engine/src/bytecompiler/statement/try.rs b/boa_engine/src/bytecompiler/statement/try.rs
index 6f9edfeb230..f26eed4f9cb 100644
--- a/boa_engine/src/bytecompiler/statement/try.rs
+++ b/boa_engine/src/bytecompiler/statement/try.rs
@@ -1,5 +1,5 @@
 use crate::{
-    bytecompiler::{ByteCompiler, Label},
+    bytecompiler::{jump_control::JumpControlInfoFlags, ByteCompiler},
     vm::{BindingOpcode, Opcode},
 };
 use boa_ast::{
@@ -10,25 +10,35 @@ use boa_ast::{
 
 impl ByteCompiler<'_, '_> {
     pub(crate) fn compile_try(&mut self, t: &Try, use_expr: bool) {
+        // stack:
+
         let try_start = self.next_opcode_location();
-        let (catch_start, finally_loc) = self.emit_opcode_with_two_operands(Opcode::TryStart);
-        self.patch_jump_with_target(finally_loc, u32::MAX);
 
-        // If there is a finally block, initialize the finally control block prior to pushing the try block jump_control
-        if t.finally().is_some() {
-            self.push_init_finally_control_info(use_expr);
-        }
-        self.push_try_control_info(t.finally().is_some(), try_start, use_expr);
+        let has_catch = t.catch().is_some();
+        let has_finally = t.finally().is_some();
+        self.push_try_control_info(has_finally, try_start, use_expr);
 
+        // Compile try block
         self.compile_block(t.block(), use_expr);
 
-        self.emit_opcode(Opcode::TryEnd);
+        let end_address = self.next_opcode_location();
+
+        // TODO: simplify when there is finally but no catch.
+        if has_finally {
+            self.emit_opcode(Opcode::PushZero);
+            self.emit_opcode(Opcode::PushFalse);
+        }
 
         let finally = self.jump();
-        self.patch_jump(catch_start);
+
+        let catch_start = self.next_opcode_location();
+        self.patch_handler(end_address, catch_start);
 
         if let Some(catch) = t.catch() {
-            self.compile_catch_stmt(catch, t.finally().is_some(), use_expr);
+            self.compile_catch_stmt(catch, has_finally, use_expr);
+        } else {
+            self.emit_opcode(Opcode::Exception);
+            self.emit_opcode(Opcode::PushTrue);
         }
 
         self.patch_jump(finally);
@@ -37,22 +47,33 @@ impl ByteCompiler<'_, '_> {
             // Pop and push control loops post FinallyStart, as FinallyStart resets flow control variables.
             // Handle finally header operations
             let finally_start = self.next_opcode_location();
-            let finally_end = self.emit_opcode_with_operand(Opcode::FinallyStart);
-            self.pop_try_control_info(finally_start);
-            self.set_jump_control_start_address(finally_start);
-            self.patch_jump_with_target(finally_loc, finally_start);
+
+            self.jump_info
+                .last_mut()
+                .expect("there should be a try block")
+                .flags |= JumpControlInfoFlags::IN_FINALLY;
+
             // Compile finally statement body
-            self.compile_finally_stmt(finally, finally_end);
+            self.compile_finally_stmt(finally, has_catch);
+
+            self.pop_try_control_info(finally_start);
         } else {
             let try_end = self.next_opcode_location();
             self.pop_try_control_info(try_end);
         }
     }
 
-    pub(crate) fn compile_catch_stmt(&mut self, catch: &Catch, _finally: bool, use_expr: bool) {
+    pub(crate) fn compile_catch_stmt(&mut self, catch: &Catch, has_finally: bool, use_expr: bool) {
+        // stack: exception
+        if has_finally {
+            let catch_start = self.next_opcode_location();
+            self.push_finally_control_info(catch_start, use_expr);
+        }
+
         self.push_compile_environment(false);
         let push_env = self.emit_opcode_with_operand(Opcode::PushDeclarativeEnvironment);
 
+        self.emit_opcode(Opcode::Exception);
         if let Some(binding) = catch.parameter() {
             match binding {
                 Binding::Identifier(ident) => {
@@ -75,16 +96,36 @@ impl ByteCompiler<'_, '_> {
         let env_index = self.pop_compile_environment();
         self.patch_jump_with_target(push_env, env_index);
         self.emit_opcode(Opcode::PopEnvironment);
+
+        if has_finally {
+            self.emit_opcode(Opcode::PushZero);
+            self.emit_opcode(Opcode::PushFalse);
+
+            let exit = self.jump();
+
+            let end_catch = self.next_opcode_location();
+            self.patch_handler(end_catch, end_catch);
+            self.pop_finally_control_info();
+
+            self.emit_opcode(Opcode::PushTrue);
+
+            self.patch_jump(exit);
+        }
     }
 
-    pub(crate) fn compile_finally_stmt(&mut self, finally: &Finally, finally_end_label: Label) {
+    pub(crate) fn compile_finally_stmt(&mut self, finally: &Finally, has_catch: bool) {
         // TODO: We could probably remove the Get/SetReturnValue if we check that there is no break/continues statements.
         self.emit_opcode(Opcode::GetReturnValue);
         self.compile_block(finally.block(), true);
         self.emit_opcode(Opcode::SetReturnValue);
 
-        self.pop_finally_control_info();
-        self.patch_jump(finally_end_label);
-        self.emit_opcode(Opcode::FinallyEnd);
+        let has_throw_exit = self.jump_if_false();
+        if !has_catch {
+            self.emit_opcode(Opcode::Throw);
+        }
+
+        // Rethrow error if error happend!
+        self.emit_opcode(Opcode::ReThrow);
+        self.patch_jump(has_throw_exit);
     }
 }
diff --git a/boa_engine/src/module/source.rs b/boa_engine/src/module/source.rs
index 2e3cde20db4..4bda801c8d3 100644
--- a/boa_engine/src/module/source.rs
+++ b/boa_engine/src/module/source.rs
@@ -1729,7 +1729,8 @@ impl SourceTextModule {
             _ => unreachable!("`execute` should only be called for evaluating modules."),
         };
 
-        let mut callframe = CallFrame::new(codeblock);
+        let env_fp = environments.len() as u32;
+        let mut callframe = CallFrame::new(codeblock).with_env_fp(env_fp);
         callframe.promise_capability = capability;
 
         // 4. Set the ScriptOrModule of moduleContext to module.
diff --git a/boa_engine/src/script.rs b/boa_engine/src/script.rs
index 737337bfeae..07d73da2a92 100644
--- a/boa_engine/src/script.rs
+++ b/boa_engine/src/script.rs
@@ -143,7 +143,10 @@ impl Script {
             .vm
             .active_runnable
             .replace(ActiveRunnable::Script(self.clone()));
-        context.vm.push_frame(CallFrame::new(codeblock));
+        let env_fp = context.vm.environments.len() as u32;
+        context
+            .vm
+            .push_frame(CallFrame::new(codeblock).with_env_fp(env_fp));
 
         // TODO: Here should be https://tc39.es/ecma262/#sec-globaldeclarationinstantiation
 
diff --git a/boa_engine/src/vm/call_frame/abrupt_record.rs b/boa_engine/src/vm/call_frame/abrupt_record.rs
deleted file mode 100644
index e60a7da2c03..00000000000
--- a/boa_engine/src/vm/call_frame/abrupt_record.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-//! Implements an `AbruptCompletionRecord` struct for `CallFrame` tracking.
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub(crate) enum AbruptKind {
-    Continue,
-    Break,
-    Throw,
-    Return,
-}
-
-/// The `AbruptCompletionRecord` tracks the current `AbruptCompletion` and target address of completion.
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct AbruptCompletionRecord {
-    kind: AbruptKind,
-    target: u32,
-}
-
-/// ---- `AbruptCompletionRecord` initialization methods ----
-impl AbruptCompletionRecord {
-    /// Creates an `AbruptCompletionRecord` for an abrupt `Break`.
-    pub(crate) const fn new_break() -> Self {
-        Self {
-            kind: AbruptKind::Break,
-            target: u32::MAX,
-        }
-    }
-
-    /// Creates an `AbruptCompletionRecord` for an abrupt `Continue`.
-    pub(crate) const fn new_continue() -> Self {
-        Self {
-            kind: AbruptKind::Continue,
-            target: u32::MAX,
-        }
-    }
-
-    /// Creates an `AbruptCompletionRecord` for an abrupt `Throw`.
-    pub(crate) const fn new_throw() -> Self {
-        Self {
-            kind: AbruptKind::Throw,
-            target: u32::MAX,
-        }
-    }
-
-    /// Creates an `AbruptCompletionRecord` for an abrupt `Return`.
-    pub(crate) const fn new_return() -> Self {
-        Self {
-            kind: AbruptKind::Return,
-            target: u32::MAX,
-        }
-    }
-
-    /// Set the target field of the `AbruptCompletionRecord`.
-    pub(crate) const fn with_initial_target(mut self, target: u32) -> Self {
-        self.target = target;
-        self
-    }
-}
-
-/// ---- `AbruptCompletionRecord` interaction methods ----
-impl AbruptCompletionRecord {
-    /// Returns a boolean value for whether `AbruptCompletionRecord` is a break.
-    pub(crate) fn is_break(self) -> bool {
-        self.kind == AbruptKind::Break
-    }
-
-    /// Returns a boolean value for whether `AbruptCompletionRecord` is a continue.
-    pub(crate) fn is_continue(self) -> bool {
-        self.kind == AbruptKind::Continue
-    }
-
-    /// Returns a boolean value for whether `AbruptCompletionRecord` is a return.
-    pub(crate) fn is_return(self) -> bool {
-        self.kind == AbruptKind::Return
-    }
-
-    /// Returns a boolean value for whether `AbruptCompletionRecord` is a throw.
-    pub(crate) fn is_throw(self) -> bool {
-        self.kind == AbruptKind::Throw
-    }
-
-    pub(crate) fn is_throw_with_target(self) -> bool {
-        self.is_throw() && self.target < u32::MAX
-    }
-
-    /// Returns the value of `AbruptCompletionRecord`'s `target` field.
-    pub(crate) const fn target(self) -> u32 {
-        self.target
-    }
-}
diff --git a/boa_engine/src/vm/call_frame/env_stack.rs b/boa_engine/src/vm/call_frame/env_stack.rs
deleted file mode 100644
index 76cf451f4ea..00000000000
--- a/boa_engine/src/vm/call_frame/env_stack.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-//! Module for implementing a `CallFrame`'s environment stacks
-
-#[derive(Clone, Debug)]
-pub(crate) enum EnvEntryKind {
-    Global,
-    Loop {
-        /// How many iterations a loop has done.
-        iteration_count: u64,
-
-        /// The index of the currently active iterator.
-        iterator: Option<u32>,
-    },
-    Try {
-        /// The length of the value stack when the try block was entered.
-        ///
-        /// This is used to pop exact amount values from the stack
-        /// when a throw happens.
-        fp: u32,
-    },
-    Finally,
-    Labelled,
-}
-
-/// The `EnvStackEntry` tracks the environment count and relevant information for the current environment.
-#[derive(Clone, Debug)]
-pub(crate) struct EnvStackEntry {
-    start: u32,
-    exit: u32,
-    kind: EnvEntryKind,
-    env_num: usize,
-}
-
-impl Default for EnvStackEntry {
-    fn default() -> Self {
-        Self {
-            start: 0,
-            exit: u32::MAX,
-            kind: EnvEntryKind::Global,
-            env_num: 0,
-        }
-    }
-}
-
-/// ---- `EnvStackEntry` creation methods ----
-impl EnvStackEntry {
-    /// Creates a new [`EnvStackEntry`] with the supplied start addresses.
-    pub(crate) const fn new(start_address: u32, exit_address: u32) -> Self {
-        Self {
-            start: start_address,
-            exit: exit_address,
-            kind: EnvEntryKind::Global,
-            env_num: 0,
-        }
-    }
-
-    /// Returns calling [`EnvStackEntry`] with `kind` field of [`EnvEntryKind::Try`].
-    pub(crate) const fn with_try_flag(mut self, fp: u32) -> Self {
-        self.kind = EnvEntryKind::Try { fp };
-        self
-    }
-
-    /// Returns calling [`EnvStackEntry`] with `kind` field of [`EnvEntryKind::Loop`], loop iteration set to zero
-    /// and iterator index set to `iterator`.
-    pub(crate) const fn with_iterator_loop_flag(
-        mut self,
-        iteration_count: u64,
-        iterator: u32,
-    ) -> Self {
-        self.kind = EnvEntryKind::Loop {
-            iteration_count,
-            iterator: Some(iterator),
-        };
-        self
-    }
-
-    /// Returns calling [`EnvStackEntry`] with `kind` field of [`EnvEntryKind::Loop`].
-    /// And the loop iteration set to zero.
-    pub(crate) const fn with_loop_flag(mut self, iteration_count: u64) -> Self {
-        self.kind = EnvEntryKind::Loop {
-            iteration_count,
-            iterator: None,
-        };
-        self
-    }
-
-    /// Returns calling [`EnvStackEntry`] with `kind` field of [`EnvEntryKind::Finally`].
-    pub(crate) const fn with_finally_flag(mut self) -> Self {
-        self.kind = EnvEntryKind::Finally;
-        self
-    }
-
-    /// Returns calling [`EnvStackEntry`] with `kind` field of [`EnvEntryKind::Labelled`].
-    pub(crate) const fn with_labelled_flag(mut self) -> Self {
-        self.kind = EnvEntryKind::Labelled;
-        self
-    }
-
-    pub(crate) const fn with_start_address(mut self, start_address: u32) -> Self {
-        self.start = start_address;
-        self
-    }
-}
-
-/// ---- `EnvStackEntry` interaction methods ----
-impl EnvStackEntry {
-    /// Returns the `start` field of this `EnvStackEntry`.
-    pub(crate) const fn start_address(&self) -> u32 {
-        self.start
-    }
-
-    /// Returns the `exit` field of this `EnvStackEntry`.
-    pub(crate) const fn exit_address(&self) -> u32 {
-        self.exit
-    }
-
-    /// Returns the `fp` field of this [`EnvEntryKind::Try`].
-    ///
-    /// # Panics
-    ///
-    /// If this [`EnvStackEntry`] is **not** a [`EnvEntryKind::Try`].
-    pub(crate) fn try_env_frame_pointer(&self) -> u32 {
-        if let EnvEntryKind::Try { fp } = &self.kind {
-            return *fp;
-        }
-        unreachable!("trying to get frame pointer of a non-try environment")
-    }
-
-    pub(crate) const fn is_global_env(&self) -> bool {
-        matches!(self.kind, EnvEntryKind::Global)
-    }
-
-    /// Returns the loop iteration count if `EnvStackEntry` is a loop.
-    pub(crate) const fn as_loop_iteration_count(&self) -> Option<u64> {
-        if let EnvEntryKind::Loop {
-            iteration_count, ..
-        } = self.kind
-        {
-            return Some(iteration_count);
-        }
-        None
-    }
-
-    /// Increases loop iteration count if `EnvStackEntry` is a loop.
-    pub(crate) fn increase_loop_iteration_count(&mut self) {
-        if let EnvEntryKind::Loop {
-            iteration_count, ..
-        } = &mut self.kind
-        {
-            *iteration_count = iteration_count.wrapping_add(1);
-        }
-    }
-
-    /// Returns the active iterator index if `EnvStackEntry` is an iterator loop.
-    pub(crate) const fn iterator(&self) -> Option<u32> {
-        if let EnvEntryKind::Loop { iterator, .. } = self.kind {
-            return iterator;
-        }
-        None
-    }
-
-    /// Returns true if an `EnvStackEntry` is a try block
-    pub(crate) const fn is_try_env(&self) -> bool {
-        matches!(self.kind, EnvEntryKind::Try { .. })
-    }
-
-    /// Returns true if an `EnvStackEntry` is a labelled block
-    pub(crate) const fn is_labelled_env(&self) -> bool {
-        matches!(self.kind, EnvEntryKind::Labelled)
-    }
-
-    pub(crate) const fn is_finally_env(&self) -> bool {
-        matches!(self.kind, EnvEntryKind::Finally)
-    }
-
-    pub(crate) const fn is_loop_env(&self) -> bool {
-        matches!(self.kind, EnvEntryKind::Loop { .. })
-    }
-
-    /// Returns the current environment number for this entry.
-    pub(crate) const fn env_num(&self) -> usize {
-        self.env_num
-    }
-
-    pub(crate) fn set_exit_address(&mut self, exit_address: u32) {
-        self.exit = exit_address;
-    }
-
-    pub(crate) fn clear_env_num(&mut self) {
-        self.env_num = 0;
-    }
-
-    /// Increments the `env_num` field for current `EnvEntryStack`.
-    pub(crate) fn inc_env_num(&mut self) {
-        (self.env_num, _) = self.env_num.overflowing_add(1);
-    }
-
-    /// Decrements the `env_num` field for current `EnvEntryStack`.
-    pub(crate) fn dec_env_num(&mut self) {
-        (self.env_num, _) = self.env_num.overflowing_sub(1);
-    }
-}
diff --git a/boa_engine/src/vm/call_frame/mod.rs b/boa_engine/src/vm/call_frame/mod.rs
index de97c2cb118..470a26581b8 100644
--- a/boa_engine/src/vm/call_frame/mod.rs
+++ b/boa_engine/src/vm/call_frame/mod.rs
@@ -2,9 +2,6 @@
 //!
 //! This module will provides everything needed to implement the `CallFrame`
 
-mod abrupt_record;
-mod env_stack;
-
 use crate::{
     builtins::{iterable::IteratorRecord, promise::PromiseCapability},
     environments::BindingLocator,
@@ -15,23 +12,15 @@ use crate::{
 use boa_gc::{Finalize, Gc, Trace};
 use thin_vec::ThinVec;
 
-pub(crate) use abrupt_record::AbruptCompletionRecord;
-pub(crate) use env_stack::EnvStackEntry;
-
 /// A `CallFrame` holds the state of a function call.
 #[derive(Clone, Debug, Finalize, Trace)]
 pub struct CallFrame {
     pub(crate) code_block: Gc<CodeBlock>,
     pub(crate) pc: u32,
     pub(crate) fp: u32,
-    #[unsafe_ignore_trace]
-    pub(crate) abrupt_completion: Option<AbruptCompletionRecord>,
-    #[unsafe_ignore_trace]
-    pub(crate) r#yield: bool,
+    pub(crate) env_fp: u32,
     // Tracks the number of environments in environment entry.
     // On abrupt returns this is used to decide how many environments need to be pop'ed.
-    #[unsafe_ignore_trace]
-    pub(crate) env_stack: Vec<EnvStackEntry>,
     pub(crate) argument_count: u32,
     #[unsafe_ignore_trace]
     pub(crate) generator_resume_kind: GeneratorResumeKind,
@@ -47,6 +36,9 @@ pub struct CallFrame {
     // The stack of bindings being updated.
     pub(crate) binding_stack: Vec<BindingLocator>,
 
+    /// How many iterations a loop has done.
+    pub(crate) loop_iteration_count: u64,
+
     /// The value that is returned from the function.
     //
     // TODO(HalidOdat): Remove this and put into the stack, maybe before frame pointer.
@@ -66,20 +58,18 @@ impl CallFrame {
 impl CallFrame {
     /// Creates a new `CallFrame` with the provided `CodeBlock`.
     pub(crate) fn new(code_block: Gc<CodeBlock>) -> Self {
-        let max_length = code_block.bytecode.len() as u32;
         Self {
             code_block,
             pc: 0,
             fp: 0,
-            env_stack: Vec::from([EnvStackEntry::new(0, max_length)]),
-            abrupt_completion: None,
-            r#yield: false,
+            env_fp: 0,
             argument_count: 0,
             generator_resume_kind: GeneratorResumeKind::Normal,
             promise_capability: None,
             async_generator: None,
             iterators: ThinVec::new(),
             binding_stack: Vec::new(),
+            loop_iteration_count: 0,
             return_value: JsValue::undefined(),
         }
     }
@@ -89,6 +79,12 @@ impl CallFrame {
         self.argument_count = count;
         self
     }
+
+    /// Updates a `CallFrame`'s `env_fp` field with the value provided.
+    pub(crate) fn with_env_fp(mut self, env_fp: u32) -> Self {
+        self.env_fp = env_fp;
+        self
+    }
 }
 
 /// ---- `CallFrame` stack methods ----
@@ -96,25 +92,6 @@ impl CallFrame {
     pub(crate) fn set_frame_pointer(&mut self, pointer: u32) {
         self.fp = pointer;
     }
-
-    /// Tracks that one environment has been pushed in the current loop block.
-    pub(crate) fn inc_frame_env_stack(&mut self) {
-        self.env_stack
-            .last_mut()
-            .expect("environment stack entry must exist")
-            .inc_env_num();
-    }
-
-    /// Tracks that one environment has been pop'ed in the current loop block.
-    ///
-    /// Note:
-    ///  - This will check if the env stack has reached 0 and should be popped.
-    pub(crate) fn dec_frame_env_stack(&mut self) {
-        self.env_stack
-            .last_mut()
-            .expect("environment stack entry must exist")
-            .dec_env_num();
-    }
 }
 
 /// Indicates how a generator function that has been called/resumed should return.
diff --git a/boa_engine/src/vm/code_block.rs b/boa_engine/src/vm/code_block.rs
index b72b234a03b..779a496c407 100644
--- a/boa_engine/src/vm/code_block.rs
+++ b/boa_engine/src/vm/code_block.rs
@@ -87,6 +87,16 @@ unsafe impl Trace for CodeBlockFlags {
     empty_trace!();
 }
 
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub(crate) struct Handler {
+    pub(crate) range: std::ops::Range<u32>,
+
+    pub(crate) handler: u32,
+    pub(crate) fp: u32,
+    pub(crate) env_fp: u32,
+}
+
 /// The internal representation of a JavaScript function.
 ///
 /// A `CodeBlock` is generated for each function compiled by the
@@ -127,6 +137,10 @@ pub struct CodeBlock {
     /// Functions inside this function
     pub(crate) functions: Box<[Gc<Self>]>,
 
+    /// Static handlers for try blocks
+    #[unsafe_ignore_trace]
+    pub(crate) handlers: ThinVec<Handler>,
+
     /// Compile time environments in this function.
     ///
     // Safety: Nothing in CompileTimeEnvironment needs tracing, so this is safe.
@@ -154,6 +168,7 @@ impl CodeBlock {
             length,
             this_mode: ThisMode::Global,
             params: FormalParameterList::default(),
+            handlers: ThinVec::default(),
             compile_environments: Box::default(),
         }
     }
@@ -217,6 +232,13 @@ impl CodeBlock {
             .get()
             .contains(CodeBlockFlags::IN_CLASS_FIELD_INITIALIZER)
     }
+
+    pub(crate) fn find_handler(&self, pc: u32) -> Option<&Handler> {
+        self.handlers
+            .iter()
+            .rev()
+            .find(|&handler| handler.range.contains(&pc))
+    }
 }
 
 /// ---- `CodeBlock` private API ----
@@ -309,8 +331,6 @@ impl CodeBlock {
             | Opcode::JumpIfFalse
             | Opcode::JumpIfNotUndefined
             | Opcode::JumpIfNullOrUndefined
-            | Opcode::FinallyStart
-            | Opcode::LabelledStart
             | Opcode::Case
             | Opcode::Default
             | Opcode::LogicalAnd
@@ -331,11 +351,6 @@ impl CodeBlock {
                 format!("{operand}")
             }
             Opcode::CopyDataProperties
-            | Opcode::Break
-            | Opcode::Continue
-            | Opcode::LoopStart
-            | Opcode::IteratorLoopStart
-            | Opcode::TryStart
             | Opcode::GeneratorDelegateNext
             | Opcode::GeneratorDelegateResume => {
                 let operand1 = self.read::<u32>(*pc);
@@ -430,6 +445,21 @@ impl CodeBlock {
                 *pc += size_of::<u32>() * (count as usize + 1);
                 String::new()
             }
+            Opcode::JumpTable => {
+                let count = self.read::<u32>(*pc);
+                *pc += size_of::<u32>();
+                let default = self.read::<u32>(*pc);
+                *pc += size_of::<u32>();
+
+                let mut operands = format!("#{count}: Default: {default:4}");
+                for i in 1..=count {
+                    let address = self.read::<u32>(*pc);
+                    *pc += size_of::<u32>();
+
+                    operands += &format!(", {i}: {address}");
+                }
+                operands
+            }
             Opcode::GeneratorJumpOnResumeKind => {
                 let normal = self.read::<u32>(*pc);
                 *pc += size_of::<u32>();
@@ -510,22 +540,22 @@ impl CodeBlock {
             | Opcode::ToPropertyKey
             | Opcode::ToBoolean
             | Opcode::Throw
-            | Opcode::TryEnd
-            | Opcode::FinallyEnd
+            | Opcode::ReThrow
+            | Opcode::Exception
             | Opcode::This
             | Opcode::Super
             | Opcode::Return
             | Opcode::PopEnvironment
-            | Opcode::LoopEnd
             | Opcode::LoopContinue
-            | Opcode::LabelledEnd
             | Opcode::CreateForInIterator
             | Opcode::GetIterator
             | Opcode::GetAsyncIterator
             | Opcode::GeneratorResumeReturn
             | Opcode::IteratorNext
+            | Opcode::IteratorNextWithoutPop
             | Opcode::IteratorFinishAsyncNext
             | Opcode::IteratorValue
+            | Opcode::IteratorValueWithoutPop
             | Opcode::IteratorResult
             | Opcode::IteratorDone
             | Opcode::IteratorToArray
@@ -618,7 +648,13 @@ impl CodeBlock {
             | Opcode::Reserved53
             | Opcode::Reserved54
             | Opcode::Reserved55
-            | Opcode::Reserved56 => unreachable!("Reserved opcodes are unrechable"),
+            | Opcode::Reserved56
+            | Opcode::Reserved57
+            | Opcode::Reserved58
+            | Opcode::Reserved59
+            | Opcode::Reserved60
+            | Opcode::Reserved61
+            | Opcode::Reserved62 => unreachable!("Reserved opcodes are unrechable"),
         }
     }
 }
@@ -641,6 +677,25 @@ impl ToInternedString for CodeBlock {
         let mut pc = 0;
         let mut count = 0;
         while pc < self.bytecode.len() {
+            for (i, handler) in self.handlers.iter().enumerate().rev() {
+                if pc == handler.range.start as usize {
+                    f.push_str(&format!(
+                        "\n# Handler {i} start: handler: {}\n",
+                        handler.handler
+                    ));
+                }
+
+                if pc == handler.range.end as usize {
+                    f.push_str(&format!(
+                        "# Handler {i} end: handler: {}\n\n",
+                        handler.handler
+                    ));
+                }
+
+                if pc == handler.handler as usize {
+                    f.push('\n');
+                }
+            }
             let opcode: Opcode = self.bytecode[pc].into();
             let opcode = opcode.as_str();
             let previous_pc = pc;
@@ -690,6 +745,18 @@ impl ToInternedString for CodeBlock {
             }
         }
 
+        f.push_str("\nHandlers:\n");
+        if self.handlers.is_empty() {
+            f.push_str("    <empty>\n");
+        } else {
+            for (i, handler) in self.handlers.iter().enumerate() {
+                f.push_str(&format!(
+                    "    {i:04}: ({}..{}): handler: {}, env_fp: {}\n",
+                    handler.range.start, handler.range.end, handler.handler, handler.env_fp,
+                ));
+            }
+        }
+
         f
     }
 }
@@ -1093,6 +1160,8 @@ impl JsObject {
             )
         };
 
+        let env_fp = context.vm.environments.len() as u32;
+
         let mut last_env = code.compile_environments.len() - 1;
 
         if let Some(class_object) = class_object {
@@ -1182,7 +1251,9 @@ impl JsObject {
 
         std::mem::swap(&mut context.vm.stack, &mut stack);
 
-        let mut frame = CallFrame::new(code).with_argument_count(argument_count as u32);
+        let mut frame = CallFrame::new(code)
+            .with_argument_count(argument_count as u32)
+            .with_env_fp(env_fp);
         frame.promise_capability = promise_capability.clone();
 
         std::mem::swap(&mut context.vm.active_runnable, &mut script_or_module);
@@ -1458,9 +1529,11 @@ impl JsObject {
 
                 std::mem::swap(&mut context.vm.active_runnable, &mut script_or_module);
 
-                context
-                    .vm
-                    .push_frame(CallFrame::new(code).with_argument_count(argument_count as u32));
+                context.vm.push_frame(
+                    CallFrame::new(code)
+                        .with_argument_count(argument_count as u32)
+                        .with_env_fp(environments_len as u32),
+                );
 
                 let record = context.run();
 
diff --git a/boa_engine/src/vm/flowgraph/mod.rs b/boa_engine/src/vm/flowgraph/mod.rs
index 9b281cfbae5..13ae8dd2d61 100644
--- a/boa_engine/src/vm/flowgraph/mod.rs
+++ b/boa_engine/src/vm/flowgraph/mod.rs
@@ -17,6 +17,7 @@ pub use node::*;
 
 impl CodeBlock {
     /// Output the [`CodeBlock`] VM instructions into a [`Graph`].
+    #[allow(clippy::match_same_arms)]
     pub fn to_graph(&self, interner: &Interner, graph: &mut SubGraph) {
         // Have to remove any invalid graph chars like `<` or `>`.
         let name = if self.name() == utf16!("<main>") {
@@ -28,8 +29,6 @@ impl CodeBlock {
         graph.set_label(name);
 
         let mut environments = Vec::new();
-        let mut try_entries = Vec::new();
-        let mut returns = Vec::new();
 
         let mut pc = 0;
         while pc < self.bytecode.len() {
@@ -131,20 +130,6 @@ impl CodeBlock {
                         EdgeStyle::Line,
                     );
                 }
-                Opcode::LabelledStart => {
-                    let end_address = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-
-                    let label = format!("{opcode_str} {end_address}");
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
-                    graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
-                }
-                Opcode::LoopStart | Opcode::IteratorLoopStart => {
-                    pc += size_of::<u32>() * 2;
-
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
-                    graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
-                }
                 Opcode::TemplateLookup | Opcode::TemplateCreate => {
                     let start_address = self.read::<u32>(pc);
                     pc += size_of::<u32>();
@@ -155,38 +140,6 @@ impl CodeBlock {
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
                     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
                 }
-                Opcode::Break => {
-                    let jump_operand = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-                    let target_operand = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-
-                    let label = format!("{opcode_str} {jump_operand}, target {target_operand}");
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
-                    graph.add_edge(
-                        previous_pc,
-                        jump_operand as usize,
-                        Some("BREAK".into()),
-                        Color::Red,
-                        EdgeStyle::Line,
-                    );
-                }
-                Opcode::Continue => {
-                    let jump_address = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-                    let target_operand = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-
-                    let label = format!("{opcode_str} {jump_address}, target {target_operand}");
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
-                    graph.add_edge(
-                        previous_pc,
-                        jump_address as usize,
-                        Some("CONTINUE".into()),
-                        Color::Red,
-                        EdgeStyle::Line,
-                    );
-                }
                 Opcode::LogicalAnd | Opcode::LogicalOr | Opcode::Coalesce => {
                     let exit = self.read::<u32>(pc);
                     pc += size_of::<u32>();
@@ -283,8 +236,7 @@ impl CodeBlock {
                 | Opcode::Call
                 | Opcode::New
                 | Opcode::SuperCall
-                | Opcode::ConcatToString
-                | Opcode::FinallyStart => {
+                | Opcode::ConcatToString => {
                     pc += size_of::<u32>();
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
@@ -325,41 +277,41 @@ impl CodeBlock {
                         EdgeStyle::Line,
                     );
                 }
-                Opcode::TryStart => {
-                    let next_address = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-                    let finally_address = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
+                //  => {
+                //     let next_address = self.read::<u32>(pc);
+                //     pc += size_of::<u32>();
+                //     let finally_address = self.read::<u32>(pc);
+                //     pc += size_of::<u32>();
 
-                    try_entries.push((
-                        previous_pc,
-                        next_address,
-                        if finally_address == 0 {
-                            None
-                        } else {
-                            Some(finally_address)
-                        },
-                    ));
+                //     try_entries.push((
+                //         previous_pc,
+                //         next_address,
+                //         if finally_address == 0 {
+                //             None
+                //         } else {
+                //             Some(finally_address)
+                //         },
+                //     ));
 
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
-                    graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
-                    graph.add_edge(
-                        previous_pc,
-                        next_address as usize,
-                        Some("NEXT".into()),
-                        Color::None,
-                        EdgeStyle::Line,
-                    );
-                    if finally_address != 0 {
-                        graph.add_edge(
-                            previous_pc,
-                            finally_address as usize,
-                            Some("FINALLY".into()),
-                            Color::None,
-                            EdgeStyle::Line,
-                        );
-                    }
-                }
+                //     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
+                //     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
+                //     graph.add_edge(
+                //         previous_pc,
+                //         next_address as usize,
+                //         Some("NEXT".into()),
+                //         Color::None,
+                //         EdgeStyle::Line,
+                //     );
+                //     if finally_address != 0 {
+                //         graph.add_edge(
+                //             previous_pc,
+                //             finally_address as usize,
+                //             Some("FINALLY".into()),
+                //             Color::None,
+                //             EdgeStyle::Line,
+                //         );
+                //     }
+                // }
                 Opcode::CopyDataProperties => {
                     let operand1 = self.read::<u32>(pc);
                     pc += size_of::<u32>();
@@ -483,33 +435,36 @@ impl CodeBlock {
                     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
                 }
                 Opcode::ThrowNewTypeError => {
+                    // FIXME:
+                    //
                     pc += size_of::<u32>();
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
-                    if let Some((_try_pc, next, _finally)) = try_entries.last() {
-                        graph.add_edge(
-                            previous_pc,
-                            *next as usize,
-                            Some("CAUGHT".into()),
-                            Color::None,
-                            EdgeStyle::Line,
-                        );
-                    } else {
-                        returns.push(previous_pc);
-                    }
-                }
-                Opcode::Throw => {
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
-                    if let Some((_try_pc, next, _finally)) = try_entries.last() {
-                        graph.add_edge(
-                            previous_pc,
-                            *next as usize,
-                            Some("CAUGHT".into()),
-                            Color::None,
-                            EdgeStyle::Line,
-                        );
-                    } else {
-                        returns.push(previous_pc);
-                    }
+                    // graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
+                    // if let Some((_try_pc, next, _finally)) = try_entries.last() {
+                    //     graph.add_edge(
+                    //         previous_pc,
+                    //         *next as usize,
+                    //         Some("CAUGHT".into()),
+                    //         Color::None,
+                    //         EdgeStyle::Line,
+                    //     );
+                    // } else {
+                    //     returns.push(previous_pc);
+                    // }
+                }
+                Opcode::Throw | Opcode::ReThrow => {
+                    // FIXME:
+                    // graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
+                    // if let Some((_try_pc, next, _finally)) = try_entries.last() {
+                    //     graph.add_edge(
+                    //         previous_pc,
+                    //         *next as usize,
+                    //         Some("CAUGHT".into()),
+                    //         Color::None,
+                    //         EdgeStyle::Line,
+                    //     );
+                    // } else {
+                    //     returns.push(previous_pc);
+                    // }
                 }
                 Opcode::PushPrivateEnvironment => {
                     let count = self.read::<u32>(pc);
@@ -517,6 +472,13 @@ impl CodeBlock {
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
                 }
+                Opcode::JumpTable => {
+                    let count = self.read::<u32>(pc);
+                    pc += size_of::<u32>() * (count as usize + 2);
+
+                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
+                    graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
+                }
                 Opcode::Pop
                 | Opcode::Dup
                 | Opcode::Swap
@@ -582,18 +544,17 @@ impl CodeBlock {
                 | Opcode::DeleteSuperThrow
                 | Opcode::ToPropertyKey
                 | Opcode::ToBoolean
-                | Opcode::FinallyEnd
                 | Opcode::This
                 | Opcode::Super
-                | Opcode::LoopEnd
                 | Opcode::LoopContinue
-                | Opcode::LabelledEnd
                 | Opcode::CreateForInIterator
                 | Opcode::GetIterator
                 | Opcode::GetAsyncIterator
                 | Opcode::IteratorNext
+                | Opcode::IteratorNextWithoutPop
                 | Opcode::IteratorFinishAsyncNext
                 | Opcode::IteratorValue
+                | Opcode::IteratorValueWithoutPop
                 | Opcode::IteratorResult
                 | Opcode::IteratorDone
                 | Opcode::IteratorToArray
@@ -630,31 +591,26 @@ impl CodeBlock {
                 | Opcode::GeneratorSetReturn
                 | Opcode::GetReturnValue
                 | Opcode::SetReturnValue
+                | Opcode::Exception
                 | Opcode::Nop => {
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                     graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
                 }
-                Opcode::TryEnd => {
-                    try_entries
-                        .pop()
-                        .expect("there should already be try block");
-
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
-                    graph.add_edge(previous_pc, pc, None, Color::None, EdgeStyle::Line);
-                }
                 Opcode::Return | Opcode::GeneratorResumeReturn => {
-                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
-                    if let Some((_try_pc, _next, Some(finally))) = try_entries.last() {
-                        graph.add_edge(
-                            previous_pc,
-                            *finally as usize,
-                            None,
-                            Color::None,
-                            EdgeStyle::Line,
-                        );
-                    } else {
-                        returns.push(previous_pc);
-                    }
+                    // FIXME:
+                    //
+                    // graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
+                    // if let Some((_try_pc, _next, Some(finally))) = try_entries.last() {
+                    //     graph.add_edge(
+                    //         previous_pc,
+                    //         *finally as usize,
+                    //         None,
+                    //         Color::None,
+                    //         EdgeStyle::Line,
+                    //     );
+                    // } else {
+                    //     returns.push(previous_pc);
+                    // }
                 }
                 Opcode::Reserved1
                 | Opcode::Reserved2
@@ -711,13 +667,20 @@ impl CodeBlock {
                 | Opcode::Reserved53
                 | Opcode::Reserved54
                 | Opcode::Reserved55
-                | Opcode::Reserved56 => unreachable!("Reserved opcodes are unrechable"),
+                | Opcode::Reserved56
+                | Opcode::Reserved57
+                | Opcode::Reserved58
+                | Opcode::Reserved59
+                | Opcode::Reserved60
+                | Opcode::Reserved61
+                | Opcode::Reserved62 => unreachable!("Reserved opcodes are unrechable"),
             }
         }
 
-        for ret in returns {
-            graph.add_edge(ret, pc, None, Color::None, EdgeStyle::Line);
-        }
+        // TODO: FIXME:
+        // for ret in returns {
+        //     graph.add_edge(ret, pc, None, Color::None, EdgeStyle::Line);
+        // }
 
         graph.add_node(pc, NodeShape::Diamond, "End".into(), Color::Red);
 
diff --git a/boa_engine/src/vm/mod.rs b/boa_engine/src/vm/mod.rs
index 27f81aaced3..235c01bc398 100644
--- a/boa_engine/src/vm/mod.rs
+++ b/boa_engine/src/vm/mod.rs
@@ -40,7 +40,7 @@ pub(crate) use {
     call_frame::GeneratorResumeKind,
     code_block::{
         create_function_object, create_function_object_fast, create_generator_function_object,
-        CodeBlockFlags,
+        CodeBlockFlags, Handler,
     },
     completion_record::CompletionRecord,
     opcode::BindingOpcode,
@@ -154,6 +154,7 @@ pub(crate) enum CompletionType {
     Normal,
     Return,
     Throw,
+    Yield,
 }
 
 impl Context<'_> {
@@ -290,6 +291,11 @@ impl Context<'_> {
                 Ok(CompletionType::Throw) => {
                     break CompletionType::Throw;
                 }
+                // Early return immediately.
+                Ok(CompletionType::Yield) => {
+                    let result = self.vm.pop();
+                    return CompletionRecord::Return(result);
+                }
                 Err(err) => {
                     #[cfg(feature = "fuzz")]
                     {
@@ -314,8 +320,7 @@ impl Context<'_> {
 
                     self.vm.err = Some(err);
 
-                    // If this frame has not evaluated the throw as an AbruptCompletion, then evaluate it
-                    let evaluation = Opcode::Throw
+                    let evaluation = Opcode::ReThrow
                         .execute(self)
                         .expect("Opcode::Throw cannot return Err");
 
@@ -328,13 +333,6 @@ impl Context<'_> {
             }
         };
 
-        // Early return immediately after loop.
-        if self.vm.frame().r#yield {
-            self.vm.frame_mut().r#yield = false;
-            let result = self.vm.pop();
-            return CompletionRecord::Return(result);
-        }
-
         #[cfg(feature = "trace")]
         if self.vm.trace {
             println!("\nStack:");
@@ -359,11 +357,6 @@ impl Context<'_> {
             println!("\n");
         }
 
-        if execution_completion == CompletionType::Throw
-            || execution_completion == CompletionType::Return
-        {
-            self.vm.frame_mut().abrupt_completion = None;
-        }
         self.vm.stack.truncate(self.vm.frame().fp as usize);
 
         // Determine the execution result
@@ -391,6 +384,7 @@ impl Context<'_> {
                         .expect("cannot fail per spec");
                     self.vm.err = Some(err);
                 }
+                CompletionType::Yield => unreachable!(),
             }
         } else if let Some(generator_object) = self.vm.frame().async_generator.clone() {
             // Step 3.e-g in [AsyncGeneratorStart](https://tc39.es/ecma262/#sec-asyncgeneratorstart)
diff --git a/boa_engine/src/vm/opcode/await_stm/mod.rs b/boa_engine/src/vm/opcode/await_stm/mod.rs
index 6296da9294a..25c92b767de 100644
--- a/boa_engine/src/vm/opcode/await_stm/mod.rs
+++ b/boa_engine/src/vm/opcode/await_stm/mod.rs
@@ -126,7 +126,6 @@ impl Operation for Await {
         );
 
         context.vm.push(JsValue::undefined());
-        context.vm.frame_mut().r#yield = true;
-        Ok(CompletionType::Return)
+        Ok(CompletionType::Yield)
     }
 }
diff --git a/boa_engine/src/vm/opcode/control_flow/break.rs b/boa_engine/src/vm/opcode/control_flow/break.rs
deleted file mode 100644
index f940fb77bb6..00000000000
--- a/boa_engine/src/vm/opcode/control_flow/break.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use crate::{
-    vm::{call_frame::AbruptCompletionRecord, opcode::Operation, CompletionType},
-    Context, JsResult,
-};
-
-/// `Break` implements the Opcode Operation for `Opcode::Break`
-///
-/// Operation:
-///   - Pop required environments and jump to address.
-pub(crate) struct Break;
-
-impl Operation for Break {
-    const NAME: &'static str = "Break";
-    const INSTRUCTION: &'static str = "INST - Break";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let jump_address = context.vm.read::<u32>();
-        let target_address = context.vm.read::<u32>();
-
-        // 1. Iterate through Env stack looking for exit address.
-        let mut envs_to_pop = 0;
-        let mut found_target = false;
-        for i in (0..context.vm.frame().env_stack.len()).rev() {
-            if found_target {
-                break;
-            }
-
-            let Some(env_entry) = context.vm.frame_mut().env_stack.get_mut(i) else {
-                break;
-            };
-
-            if jump_address == env_entry.exit_address()
-                || (env_entry.is_finally_env() && jump_address == env_entry.start_address())
-            {
-                found_target = true;
-                continue;
-            }
-
-            envs_to_pop += env_entry.env_num();
-            context.vm.frame_mut().env_stack.pop();
-        }
-
-        let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-        context.vm.environments.truncate(env_truncation_len);
-
-        // 2. Register target address in AbruptCompletionRecord.
-        let new_record = AbruptCompletionRecord::new_break().with_initial_target(target_address);
-        context.vm.frame_mut().abrupt_completion = Some(new_record);
-
-        // 3. Set program counter and finally return fields.
-        context.vm.frame_mut().pc = jump_address;
-        Ok(CompletionType::Normal)
-    }
-}
diff --git a/boa_engine/src/vm/opcode/control_flow/continue.rs b/boa_engine/src/vm/opcode/control_flow/continue.rs
deleted file mode 100644
index be97fedc237..00000000000
--- a/boa_engine/src/vm/opcode/control_flow/continue.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use crate::{
-    vm::{call_frame::AbruptCompletionRecord, opcode::Operation, CompletionType},
-    Context, JsResult,
-};
-
-/// `Continue` implements the Opcode Operation for `Opcode::Continue`
-///
-/// Operands:
-///   - Target address
-///   - Initial environments to reconcile on continue (will be tracked along with changes to environment stack)
-///
-/// Operation:
-///   - Initializes the `AbruptCompletionRecord` for a delayed continued in a `Opcode::FinallyEnd`
-pub(crate) struct Continue;
-
-impl Operation for Continue {
-    const NAME: &'static str = "Continue";
-    const INSTRUCTION: &'static str = "INST - Continue";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let jump_address = context.vm.read::<u32>();
-        let target_address = context.vm.read::<u32>();
-
-        // 1. Iterate through Env stack looking for exit address.
-        let mut envs_to_pop = 0;
-        let mut found_target = false;
-        for i in (0..context.vm.frame().env_stack.len()).rev() {
-            if found_target {
-                break;
-            }
-
-            let Some(env_entry) = context.vm.frame_mut().env_stack.get_mut(i) else {
-                break;
-            };
-
-            // We check two conditions here where continue actually jumps to a higher address.
-            //   1. When we have reached a finally env that matches the jump address we are moving to.
-            //   2. When there is no finally, and we have reached the continue location.
-            if (env_entry.is_finally_env() && jump_address == env_entry.start_address())
-                || (jump_address == target_address && jump_address == env_entry.start_address())
-            {
-                found_target = true;
-                continue;
-            }
-
-            envs_to_pop += env_entry.env_num();
-            // The below check determines whether we have continued from inside of a finally block.
-            if jump_address > target_address && jump_address == env_entry.exit_address() {
-                found_target = true;
-                context.vm.frame_mut().env_stack.pop();
-                continue;
-            }
-            context.vm.frame_mut().env_stack.pop();
-        }
-
-        let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-        context.vm.environments.truncate(env_truncation_len);
-
-        // 2. Register target address in AbruptCompletionRecord.
-        let new_record = AbruptCompletionRecord::new_continue().with_initial_target(target_address);
-        context.vm.frame_mut().abrupt_completion = Some(new_record);
-
-        // 3. Set program counter and finally return fields.
-        context.vm.frame_mut().pc = jump_address;
-        Ok(CompletionType::Normal)
-    }
-}
diff --git a/boa_engine/src/vm/opcode/control_flow/finally.rs b/boa_engine/src/vm/opcode/control_flow/finally.rs
deleted file mode 100644
index 9a41e2dc163..00000000000
--- a/boa_engine/src/vm/opcode/control_flow/finally.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-use crate::{
-    vm::{opcode::Operation, CompletionType},
-    Context, JsError, JsResult,
-};
-
-/// `FinallyStart` implements the Opcode Operation for `Opcode::FinallyStart`
-///
-/// Operation:
-///  - Start of a finally block.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct FinallyStart;
-
-impl Operation for FinallyStart {
-    const NAME: &'static str = "FinallyStart";
-    const INSTRUCTION: &'static str = "INST - FinallyStart";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let exit = context.vm.read::<u32>();
-
-        let finally_env = context
-            .vm
-            .frame_mut()
-            .env_stack
-            .last_mut()
-            .expect("EnvStackEntries must exist");
-
-        finally_env.set_exit_address(exit);
-        Ok(CompletionType::Normal)
-    }
-}
-
-/// `FinallyEnd` implements the Opcode Operation for `Opcode::FinallyEnd`
-///
-/// Operation:
-///  - End of a finally block.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct FinallyEnd;
-
-impl Operation for FinallyEnd {
-    const NAME: &'static str = "FinallyEnd";
-    const INSTRUCTION: &'static str = "INST - FinallyEnd";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let finally_candidates = context
-            .vm
-            .frame()
-            .env_stack
-            .iter()
-            .filter(|env| env.is_finally_env() && context.vm.frame().pc < env.start_address());
-
-        let next_finally = match finally_candidates.last() {
-            Some(env) => env.start_address(),
-            _ => u32::MAX,
-        };
-
-        let mut envs_to_pop = 0;
-        match context.vm.frame().abrupt_completion {
-            Some(record) if next_finally < record.target() => {
-                context.vm.frame_mut().pc = next_finally;
-
-                while let Some(env_entry) = context.vm.frame().env_stack.last() {
-                    if next_finally <= env_entry.exit_address() {
-                        break;
-                    }
-
-                    envs_to_pop += env_entry.env_num();
-                    context.vm.frame_mut().env_stack.pop();
-                }
-
-                let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-                context.vm.environments.truncate(env_truncation_len);
-            }
-            Some(record) if record.is_break() && context.vm.frame().pc < record.target() => {
-                // handle the continuation of an abrupt break.
-                context.vm.frame_mut().pc = record.target();
-                while let Some(env_entry) = context.vm.frame().env_stack.last() {
-                    if record.target() == env_entry.exit_address() {
-                        break;
-                    }
-
-                    envs_to_pop += env_entry.env_num();
-                    context.vm.frame_mut().env_stack.pop();
-                }
-
-                context.vm.frame_mut().abrupt_completion = None;
-
-                let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-                context.vm.environments.truncate(env_truncation_len);
-            }
-            Some(record) if record.is_continue() && context.vm.frame().pc > record.target() => {
-                // Handle the continuation of an abrupt continue
-                context.vm.frame_mut().pc = record.target();
-                while let Some(env_entry) = context.vm.frame().env_stack.last() {
-                    if env_entry.start_address() == record.target() {
-                        break;
-                    }
-                    envs_to_pop += env_entry.env_num();
-                    context.vm.frame_mut().env_stack.pop();
-                }
-
-                context.vm.frame_mut().abrupt_completion = None;
-                let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-                context.vm.environments.truncate(env_truncation_len);
-            }
-            Some(record) if record.is_return() => {
-                return Ok(CompletionType::Return);
-            }
-            Some(record)
-                if record.is_throw_with_target() && context.vm.frame().pc < record.target() =>
-            {
-                context.vm.frame_mut().pc = record.target();
-                while let Some(env_entry) = context.vm.frame_mut().env_stack.pop() {
-                    envs_to_pop += env_entry.env_num();
-                    if env_entry.start_address() == record.target() {
-                        break;
-                    }
-                }
-                context.vm.frame_mut().abrupt_completion = None;
-                let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-                context.vm.environments.truncate(env_truncation_len);
-            }
-            Some(record) if record.is_throw() && !record.is_throw_with_target() => {
-                let current_stack = context
-                    .vm
-                    .frame_mut()
-                    .env_stack
-                    .pop()
-                    .expect("Popping current finally stack.");
-
-                let env_truncation_len = context
-                    .vm
-                    .environments
-                    .len()
-                    .saturating_sub(current_stack.env_num());
-                context.vm.environments.truncate(env_truncation_len);
-
-                let err = JsError::from_opaque(context.vm.pop());
-                context.vm.err = Some(err);
-                return Ok(CompletionType::Throw);
-            }
-            _ => {
-                context.vm.frame_mut().env_stack.pop();
-            }
-        }
-
-        Ok(CompletionType::Normal)
-    }
-}
diff --git a/boa_engine/src/vm/opcode/control_flow/labelled.rs b/boa_engine/src/vm/opcode/control_flow/labelled.rs
deleted file mode 100644
index fac8c1aeb16..00000000000
--- a/boa_engine/src/vm/opcode/control_flow/labelled.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use crate::{
-    vm::{call_frame::EnvStackEntry, opcode::Operation, CompletionType},
-    Context, JsResult,
-};
-
-/// `LabelledStart` implements the Opcode Operation for `Opcode::LabelledStart`
-///
-/// Operation:
-///  - Start of a labelled block.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct LabelledStart;
-
-impl Operation for LabelledStart {
-    const NAME: &'static str = "LabelledStart";
-    const INSTRUCTION: &'static str = "INST - LabelledStart";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let start = context.vm.frame().pc - 1;
-        let end = context.vm.read::<u32>();
-        context
-            .vm
-            .frame_mut()
-            .env_stack
-            .push(EnvStackEntry::new(start, end).with_labelled_flag());
-        Ok(CompletionType::Normal)
-    }
-}
-
-/// `LabelledEnd` implements the Opcode Operation for `Opcode::LabelledEnd`
-///
-/// Operation:
-///  - Clean up environments at the end of labelled block.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct LabelledEnd;
-
-impl Operation for LabelledEnd {
-    const NAME: &'static str = "LabelledEnd";
-    const INSTRUCTION: &'static str = "INST - LabelledEnd";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let mut envs_to_pop = 0_usize;
-        while let Some(env_entry) = context.vm.frame_mut().env_stack.pop() {
-            envs_to_pop += env_entry.env_num();
-
-            if env_entry.is_labelled_env() {
-                break;
-            }
-        }
-
-        let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-        context.vm.environments.truncate(env_truncation_len);
-
-        Ok(CompletionType::Normal)
-    }
-}
diff --git a/boa_engine/src/vm/opcode/control_flow/mod.rs b/boa_engine/src/vm/opcode/control_flow/mod.rs
index fa3a4d7637c..a3ac8d1488f 100644
--- a/boa_engine/src/vm/opcode/control_flow/mod.rs
+++ b/boa_engine/src/vm/opcode/control_flow/mod.rs
@@ -1,15 +1,5 @@
-pub(crate) mod r#break;
-pub(crate) mod r#continue;
-pub(crate) mod finally;
-pub(crate) mod labelled;
 pub(crate) mod r#return;
 pub(crate) mod throw;
-pub(crate) mod r#try;
 
-pub(crate) use finally::*;
-pub(crate) use labelled::*;
-pub(crate) use r#break::*;
-pub(crate) use r#continue::*;
 pub(crate) use r#return::*;
-pub(crate) use r#try::*;
 pub(crate) use throw::*;
diff --git a/boa_engine/src/vm/opcode/control_flow/return.rs b/boa_engine/src/vm/opcode/control_flow/return.rs
index b44a7f05583..17e88983906 100644
--- a/boa_engine/src/vm/opcode/control_flow/return.rs
+++ b/boa_engine/src/vm/opcode/control_flow/return.rs
@@ -1,5 +1,5 @@
 use crate::{
-    vm::{call_frame::AbruptCompletionRecord, opcode::Operation, CompletionType},
+    vm::{opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
@@ -14,39 +14,7 @@ impl Operation for Return {
     const NAME: &'static str = "Return";
     const INSTRUCTION: &'static str = "INST - Return";
 
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let current_address = context.vm.frame().pc;
-        let mut env_to_pop = 0;
-        let mut finally_address = None;
-        while let Some(env_entry) = context.vm.frame().env_stack.last() {
-            if env_entry.is_finally_env() {
-                if env_entry.start_address() < current_address {
-                    finally_address = Some(env_entry.exit_address());
-                } else {
-                    finally_address = Some(env_entry.start_address());
-                }
-                break;
-            }
-
-            env_to_pop += env_entry.env_num();
-            if env_entry.is_global_env() {
-                break;
-            }
-
-            context.vm.frame_mut().env_stack.pop();
-        }
-
-        let env_truncation_len = context.vm.environments.len().saturating_sub(env_to_pop);
-        context.vm.environments.truncate(env_truncation_len);
-
-        let record = AbruptCompletionRecord::new_return();
-        context.vm.frame_mut().abrupt_completion = Some(record);
-
-        if let Some(finally) = finally_address {
-            context.vm.frame_mut().pc = finally;
-            return Ok(CompletionType::Normal);
-        }
-
+    fn execute(_context: &mut Context<'_>) -> JsResult<CompletionType> {
         Ok(CompletionType::Return)
     }
 }
diff --git a/boa_engine/src/vm/opcode/control_flow/throw.rs b/boa_engine/src/vm/opcode/control_flow/throw.rs
index 0a254d18691..eabf98278d9 100644
--- a/boa_engine/src/vm/opcode/control_flow/throw.rs
+++ b/boa_engine/src/vm/opcode/control_flow/throw.rs
@@ -1,10 +1,6 @@
 use crate::{
-    vm::{
-        call_frame::{AbruptCompletionRecord, EnvStackEntry},
-        opcode::Operation,
-        CompletionType,
-    },
-    Context, JsError, JsNativeError, JsResult, JsValue,
+    vm::{opcode::Operation, CompletionType},
+    Context, JsError, JsNativeError, JsResult,
 };
 
 /// `Throw` implements the Opcode Operation for `Opcode::Throw`
@@ -19,168 +15,82 @@ impl Operation for Throw {
     const INSTRUCTION: &'static str = "INST - Throw";
 
     fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let error = if let Some(err) = context.vm.err.take() {
-            err
-        } else {
-            JsError::from_opaque(context.vm.pop())
-        };
-
-        // 1. Find the viable catch and finally blocks
-        let current_address = context.vm.frame().pc;
-        let mut envs = context.vm.frame().env_stack.iter();
-
-        // Handle catch block
-        if let Some(idx) =
-            envs.rposition(|env| env.is_try_env() && env.start_address() != env.exit_address())
-        {
-            let active_iterator = context.vm.frame().env_stack[..idx]
-                .iter()
-                .filter_map(EnvStackEntry::iterator)
-                .last();
-
-            // Close all iterators that are outside the catch context.
-            if let Some(active_iterator) = active_iterator {
-                let inactive = context
-                    .vm
-                    .frame_mut()
-                    .iterators
-                    .split_off(active_iterator as usize + 1);
-                for iterator in inactive {
-                    if !iterator.done() {
-                        drop(iterator.close(Ok(JsValue::undefined()), context));
-                    }
-                }
-                context.vm.err.take();
-            }
-
-            let try_env = &context.vm.frame().env_stack[idx];
-            let try_env_frame_pointer = try_env.try_env_frame_pointer();
-            context.vm.stack.truncate(try_env_frame_pointer as usize);
-
-            let catch_target = context.vm.frame().env_stack[idx].start_address();
-
-            let mut env_to_pop = 0;
-            let mut target_address = u32::MAX;
-            while context.vm.frame().env_stack.len() > 1 {
-                let env_entry = context
-                    .vm
-                    .frame_mut()
-                    .env_stack
-                    .last()
-                    .expect("EnvStackEntries must exist");
-
-                if env_entry.is_try_env() && env_entry.start_address() < env_entry.exit_address() {
-                    target_address = env_entry.start_address();
-                    env_to_pop += env_entry.env_num();
-                    context.vm.frame_mut().env_stack.pop();
-                    break;
-                } else if env_entry.is_finally_env() {
-                    if current_address > env_entry.start_address() {
-                        target_address = env_entry.exit_address();
-                    } else {
-                        target_address = env_entry.start_address();
-                    }
-                    break;
-                }
-                env_to_pop += env_entry.env_num();
-                context.vm.frame_mut().env_stack.pop();
-            }
-
-            let env_truncation_len = context.vm.environments.len().saturating_sub(env_to_pop);
-            context.vm.environments.truncate(env_truncation_len);
-
-            if target_address == catch_target {
-                context.vm.frame_mut().pc = catch_target;
-            } else {
-                context.vm.frame_mut().pc = target_address;
-            };
-
-            let record = AbruptCompletionRecord::new_throw().with_initial_target(catch_target);
-            context.vm.frame_mut().abrupt_completion = Some(record);
-            let err = error.to_opaque(context);
-            context.vm.push(err);
-            return Ok(CompletionType::Normal);
-        }
+        let error = JsError::from_opaque(context.vm.pop());
+        context.vm.err = Some(error);
 
-        let mut env_to_pop = 0;
-        let mut target_address = None;
-        let mut env_stack_to_pop = 0;
-        for env_entry in context.vm.frame_mut().env_stack.iter_mut().rev() {
-            if env_entry.is_finally_env() {
-                if env_entry.start_address() < current_address {
-                    target_address = Some(env_entry.exit_address());
-                } else {
-                    target_address = Some(env_entry.start_address());
-                }
-                break;
-            };
-
-            env_to_pop += env_entry.env_num();
-            if env_entry.is_global_env() {
-                env_entry.clear_env_num();
-                break;
-            };
-
-            env_stack_to_pop += 1;
-        }
+        let pc = context.vm.frame().pc - 1;
+        if let Some(handler) = context.vm.frame().code_block().find_handler(pc).cloned() {
+            let env_fp = context.vm.frame().env_fp;
 
-        let record = AbruptCompletionRecord::new_throw();
-        context.vm.frame_mut().abrupt_completion = Some(record);
-
-        if let Some(address) = target_address {
-            for _ in 0..env_stack_to_pop {
-                context.vm.frame_mut().env_stack.pop();
-            }
-
-            let active_iterator = context
-                .vm
-                .frame()
-                .env_stack
-                .iter()
-                .filter_map(EnvStackEntry::iterator)
-                .last();
-
-            // Close all iterators that are outside the finally context.
-            if let Some(active_iterator) = active_iterator {
-                let inactive = context
-                    .vm
-                    .frame_mut()
-                    .iterators
-                    .split_off(active_iterator as usize + 1);
-
-                for iterator in inactive {
-                    if !iterator.done() {
-                        drop(iterator.close(Ok(JsValue::undefined()), context));
-                    }
-                }
-                context.vm.err.take();
-            }
-
-            let env_truncation_len = context.vm.environments.len().saturating_sub(env_to_pop);
-            context.vm.environments.truncate(env_truncation_len);
-
-            // NOTE: There is could be leftover stack values, but this is fine,
-            // since we truncate to the call frams's frame pointer on return.
-
-            context.vm.frame_mut().pc = address;
-            let err = error.to_opaque(context);
-            context.vm.push(err);
+            let catch_address = handler.handler;
+            let env_fp = (env_fp + handler.env_fp) as usize;
+            // TODO: fp
+            // let fp = try_entry.fp() as usize;
+
+            context.vm.frame_mut().pc = catch_address;
+            context.vm.environments.truncate(env_fp);
+            // context.vm.stack.truncate(fp);
             return Ok(CompletionType::Normal);
         }
 
-        // Close all iterators that are still open.
-        for iterator in std::mem::take(&mut context.vm.frame_mut().iterators) {
-            if !iterator.done() {
-                drop(iterator.close(Ok(JsValue::undefined()), context));
-            }
+        Ok(CompletionType::Throw)
+    }
+}
+
+/// `ReThrow` implements the Opcode Operation for `Opcode::ReThrow`
+///
+/// Operation:
+///  - Rethrow thrown exception.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct ReThrow;
+
+impl Operation for ReThrow {
+    const NAME: &'static str = "ReThrow";
+    const INSTRUCTION: &'static str = "INST - ReThrow";
+
+    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
+        assert!(context.vm.err.is_some(), "Need exception to rethrow");
+
+        let pc = context.vm.frame().pc.saturating_sub(1);
+        if let Some(handler) = context.vm.frame().code_block().find_handler(pc).cloned() {
+            let env_fp = context.vm.frame().env_fp;
+
+            let catch_address = handler.handler;
+            let env_fp = (env_fp + handler.env_fp) as usize;
+            // TODO: fp
+            // let fp = try_entry.fp() as usize;
+
+            context.vm.frame_mut().pc = catch_address;
+            context.vm.environments.truncate(env_fp);
+            // context.vm.stack.truncate(fp);
+            return Ok(CompletionType::Normal);
         }
-        context.vm.err.take();
 
-        context.vm.err = Some(error);
         Ok(CompletionType::Throw)
     }
 }
 
+/// `Exception` implements the Opcode Operation for `Opcode::Exception`
+///
+/// Operation:
+///  - Get the thrown exception and push on the stack.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct Exception;
+
+impl Operation for Exception {
+    const NAME: &'static str = "Exception";
+    const INSTRUCTION: &'static str = "INST - Exception";
+
+    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
+        if let Some(error) = context.vm.err.take() {
+            let error = error.to_opaque(context);
+            context.vm.push(error);
+            return Ok(CompletionType::Normal);
+        }
+        unreachable!("")
+    }
+}
+
 /// `ThrowNewTypeError` implements the Opcode Operation for `Opcode::ThrowNewTypeError`
 ///
 /// Operation:
diff --git a/boa_engine/src/vm/opcode/control_flow/try.rs b/boa_engine/src/vm/opcode/control_flow/try.rs
deleted file mode 100644
index b79b6dc10cb..00000000000
--- a/boa_engine/src/vm/opcode/control_flow/try.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use crate::{
-    vm::{call_frame::EnvStackEntry, opcode::Operation, CompletionType},
-    Context, JsResult,
-};
-
-/// `TryStart` implements the Opcode Operation for `Opcode::TryStart`
-///
-/// Operation:
-///  - Start of a try block.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct TryStart;
-
-impl Operation for TryStart {
-    const NAME: &'static str = "TryStart";
-    const INSTRUCTION: &'static str = "INST - TryStart";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let catch = context.vm.read::<u32>();
-        let finally = context.vm.read::<u32>();
-
-        // If a finally exists, push the env to the stack before the try.
-        if finally != u32::MAX {
-            context.vm.frame_mut().env_stack.push(
-                EnvStackEntry::default()
-                    .with_finally_flag()
-                    .with_start_address(finally),
-            );
-        }
-
-        let fp = context.vm.stack.len() as u32;
-
-        context
-            .vm
-            .frame_mut()
-            .env_stack
-            .push(EnvStackEntry::new(catch, finally).with_try_flag(fp));
-
-        Ok(CompletionType::Normal)
-    }
-}
-
-/// `TryEnd` implements the Opcode Operation for `Opcode::TryEnd`
-///
-/// Operation:
-///  - End of a try block
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct TryEnd;
-
-impl Operation for TryEnd {
-    const NAME: &'static str = "TryEnd";
-    const INSTRUCTION: &'static str = "INST - TryEnd";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let mut envs_to_pop = 0_usize;
-        while let Some(env_entry) = context.vm.frame_mut().env_stack.pop() {
-            envs_to_pop += env_entry.env_num();
-
-            if env_entry.is_try_env() {
-                break;
-            }
-        }
-
-        let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-        context.vm.environments.truncate(env_truncation_len);
-
-        Ok(CompletionType::Normal)
-    }
-}
diff --git a/boa_engine/src/vm/opcode/generator/yield_stm.rs b/boa_engine/src/vm/opcode/generator/yield_stm.rs
index 8f545de58da..708e724d78e 100644
--- a/boa_engine/src/vm/opcode/generator/yield_stm.rs
+++ b/boa_engine/src/vm/opcode/generator/yield_stm.rs
@@ -15,9 +15,8 @@ impl Operation for GeneratorYield {
     const NAME: &'static str = "GeneratorYield";
     const INSTRUCTION: &'static str = "INST - GeneratorYield";
 
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        context.vm.frame_mut().r#yield = true;
-        Ok(CompletionType::Return)
+    fn execute(_context: &mut Context<'_>) -> JsResult<CompletionType> {
+        Ok(CompletionType::Yield)
     }
 }
 
diff --git a/boa_engine/src/vm/opcode/iteration/iterator.rs b/boa_engine/src/vm/opcode/iteration/iterator.rs
index 0f3450c1ff0..231615341ba 100644
--- a/boa_engine/src/vm/opcode/iteration/iterator.rs
+++ b/boa_engine/src/vm/opcode/iteration/iterator.rs
@@ -34,6 +34,35 @@ impl Operation for IteratorNext {
     }
 }
 
+/// `IteratorNextWithoutPop` implements the Opcode Operation for `Opcode::IteratorNextWithoutPop`
+///
+/// Operation:
+///  - Calls the `next` method of `iterator`, updating its record with the next value.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct IteratorNextWithoutPop;
+
+impl Operation for IteratorNextWithoutPop {
+    const NAME: &'static str = "IteratorNextWithoutPop";
+    const INSTRUCTION: &'static str = "INST - IteratorNextWithoutPop";
+
+    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
+        let mut iterator = context
+            .vm
+            .frame_mut()
+            .iterators
+            .pop()
+            .expect("iterator stack should have at least an iterator");
+
+        let result = iterator.step(context);
+
+        context.vm.frame_mut().iterators.push(iterator);
+
+        result?;
+
+        Ok(CompletionType::Normal)
+    }
+}
+
 /// `IteratorFinishAsyncNext` implements the Opcode Operation for `Opcode::IteratorFinishAsyncNext`.
 ///
 /// Operation:
@@ -129,6 +158,34 @@ impl Operation for IteratorValue {
     }
 }
 
+/// `IteratorValueWithoutPop` implements the Opcode Operation for `Opcode::IteratorValueWithoutPop`
+///
+/// Operation:
+///  - Gets the `value` property of the current iterator record.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct IteratorValueWithoutPop;
+
+impl Operation for IteratorValueWithoutPop {
+    const NAME: &'static str = "IteratorValueWithoutPop";
+    const INSTRUCTION: &'static str = "INST - IteratorValueWithoutPop";
+
+    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
+        let mut iterator = context
+            .vm
+            .frame_mut()
+            .iterators
+            .pop()
+            .expect("iterator on the call frame must exist");
+
+        let value = iterator.value(context);
+        context.vm.frame_mut().iterators.push(iterator);
+
+        context.vm.push(value?);
+
+        Ok(CompletionType::Normal)
+    }
+}
+
 /// `IteratorDone` implements the Opcode Operation for `Opcode::IteratorDone`
 ///
 /// Operation:
diff --git a/boa_engine/src/vm/opcode/iteration/loop_ops.rs b/boa_engine/src/vm/opcode/iteration/loop_ops.rs
index ef694913006..d2b248268cf 100644
--- a/boa_engine/src/vm/opcode/iteration/loop_ops.rs
+++ b/boa_engine/src/vm/opcode/iteration/loop_ops.rs
@@ -1,54 +1,9 @@
 use crate::JsNativeError;
 use crate::{
-    vm::{call_frame::EnvStackEntry, opcode::Operation, CompletionType},
+    vm::{opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
-/// `IteratorLoopStart` implements the Opcode Operation for `Opcode::IteratorLoopStart`
-///
-/// Operation:
-///  - Push iterator loop start marker.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct IteratorLoopStart;
-
-impl Operation for IteratorLoopStart {
-    const NAME: &'static str = "IteratorLoopStart";
-    const INSTRUCTION: &'static str = "INST - IteratorLoopStart";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let start = context.vm.read::<u32>();
-        let exit = context.vm.read::<u32>();
-
-        // Create and push loop evironment entry.
-        let entry = EnvStackEntry::new(start, exit)
-            .with_iterator_loop_flag(1, (context.vm.frame().iterators.len() - 1) as u32);
-        context.vm.frame_mut().env_stack.push(entry);
-        Ok(CompletionType::Normal)
-    }
-}
-
-/// `LoopStart` implements the Opcode Operation for `Opcode::LoopStart`
-///
-/// Operation:
-///  - Push loop start marker.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct LoopStart;
-
-impl Operation for LoopStart {
-    const NAME: &'static str = "LoopStart";
-    const INSTRUCTION: &'static str = "INST - LoopStart";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let start = context.vm.read::<u32>();
-        let exit = context.vm.read::<u32>();
-
-        // Create and push loop evironment entry.
-        let entry = EnvStackEntry::new(start, exit).with_loop_flag(1);
-        context.vm.frame_mut().env_stack.push(entry);
-        Ok(CompletionType::Normal)
-    }
-}
-
 /// `LoopContinue` implements the Opcode Operation for `Opcode::LoopContinue`.
 ///
 /// Operation:
@@ -61,60 +16,16 @@ impl Operation for LoopContinue {
     const INSTRUCTION: &'static str = "INST - LoopContinue";
 
     fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        // 1. Clean up the previous environment.
-        let env = context
-            .vm
-            .frame_mut()
-            .env_stack
-            .last_mut()
-            .expect("loop environment must be present");
+        let previous_iteration_count = context.vm.frame_mut().loop_iteration_count;
 
-        let env_num = env.env_num();
-        env.clear_env_num();
-
-        if let Some(previous_iteration_count) = env.as_loop_iteration_count() {
-            env.increase_loop_iteration_count();
-            let max = context.vm.runtime_limits.loop_iteration_limit();
-            if previous_iteration_count > max {
-                let env_truncation_len = context.vm.environments.len().saturating_sub(env_num);
-                context.vm.environments.truncate(env_truncation_len);
-                return Err(JsNativeError::runtime_limit()
-                    .with_message(format!("Maximum loop iteration limit {max} exceeded"))
-                    .into());
-            }
+        let max = context.vm.runtime_limits.loop_iteration_limit();
+        if previous_iteration_count > max {
+            return Err(JsNativeError::runtime_limit()
+                .with_message(format!("Maximum loop iteration limit {max} exceeded"))
+                .into());
         }
 
-        let env_truncation_len = context.vm.environments.len().saturating_sub(env_num);
-        context.vm.environments.truncate(env_truncation_len);
-
-        Ok(CompletionType::Normal)
-    }
-}
-
-/// `LoopEnd` implements the Opcode Operation for `Opcode::LoopEnd`
-///
-/// Operation:
-///  - Clean up environments at the end of a loop.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct LoopEnd;
-
-impl Operation for LoopEnd {
-    const NAME: &'static str = "LoopEnd";
-    const INSTRUCTION: &'static str = "INST - LoopEnd";
-
-    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
-        let mut envs_to_pop = 0_usize;
-        while let Some(env_entry) = context.vm.frame_mut().env_stack.pop() {
-            envs_to_pop += env_entry.env_num();
-
-            if env_entry.is_loop_env() {
-                break;
-            }
-        }
-
-        let env_truncation_len = context.vm.environments.len().saturating_sub(envs_to_pop);
-        context.vm.environments.truncate(env_truncation_len);
-
+        context.vm.frame_mut().loop_iteration_count = previous_iteration_count.wrapping_add(1);
         Ok(CompletionType::Normal)
     }
 }
diff --git a/boa_engine/src/vm/opcode/jump/mod.rs b/boa_engine/src/vm/opcode/jump/mod.rs
index d52346235e6..4579fd573e4 100644
--- a/boa_engine/src/vm/opcode/jump/mod.rs
+++ b/boa_engine/src/vm/opcode/jump/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
     vm::{opcode::Operation, CompletionType},
-    Context, JsResult,
+    Context, JsResult, JsValue,
 };
 
 /// `Jump` implements the Opcode Operation for `Opcode::Jump`
@@ -83,7 +83,7 @@ impl Operation for JumpIfNotUndefined {
     }
 }
 
-/// `JumpIfUndefined` implements the Opcode Operation for `Opcode::JumpIfUndefined`
+/// `JumpIfNullOrUndefined` implements the Opcode Operation for `Opcode::JumpIfNullOrUndefined`
 ///
 /// Operation:
 ///  - Conditional jump to address.
@@ -105,3 +105,36 @@ impl Operation for JumpIfNullOrUndefined {
         Ok(CompletionType::Normal)
     }
 }
+
+/// `JumpTable` implements the Opcode Operation for `Opcode::JumpTable`
+///
+/// Operation:
+///  - Conditional jump to address.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct JumpTable;
+
+impl Operation for JumpTable {
+    const NAME: &'static str = "JumpTable";
+    const INSTRUCTION: &'static str = "INST - JumpTable";
+
+    fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
+        let count = context.vm.read::<u32>();
+        let default = context.vm.read::<u32>();
+        let value = context.vm.pop();
+        if let JsValue::Integer(value) = &value {
+            let value = *value as u32;
+            let mut target = None;
+            for i in 0..count {
+                let address = context.vm.read::<u32>();
+                if i + 1 == value {
+                    target = Some(address);
+                }
+            }
+
+            context.vm.frame_mut().pc = target.unwrap_or(default);
+
+            return Ok(CompletionType::Normal);
+        }
+        unreachable!("expected positive integer, got {value:?}")
+    }
+}
diff --git a/boa_engine/src/vm/opcode/mod.rs b/boa_engine/src/vm/opcode/mod.rs
index 44622af89ea..6adb27b0615 100644
--- a/boa_engine/src/vm/opcode/mod.rs
+++ b/boa_engine/src/vm/opcode/mod.rs
@@ -1117,61 +1117,40 @@ generate_impl! {
         /// Stack: value **=>** value
         JumpIfNullOrUndefined,
 
-        /// Throw exception
+        /// Jump table
         ///
-        /// Operands:
+        /// Operands: count: `u32`, default: `u32`, address: `u32` * count
         ///
         /// Stack: value **=>**
-        Throw,
+        JumpTable,
 
-        /// Throw a new `TypeError` exception
-        ///
-        /// Operands: message: u32
-        ///
-        /// Stack: **=>**
-        ThrowNewTypeError,
-
-        /// Start of a try block.
-        ///
-        /// Operands: next_address: `u32`, finally_address: `u32`
-        ///
-        /// Stack: **=>**
-        TryStart,
-
-        /// End of a try block.
+        /// Throw exception
         ///
         /// Operands:
         ///
-        /// Stack: **=>**
-        TryEnd,
+        /// Stack: value **=>**
+        Throw,
 
-        /// Start of a finally block.
+        /// Rethrow thrown exception
         ///
         /// Operands:
         ///
         /// Stack: **=>**
-        FinallyStart,
+        ReThrow,
 
-        /// End of a finally block.
+        /// Get the thrown exception and push on the stack.
         ///
         /// Operands:
         ///
-        /// Stack: **=>**
-        FinallyEnd,
-
-        /// Jumps to a target location and pops the environments involved.
-        ///
-        /// Operands: Jump Address: u32, Target address: u32
-        ///
-        /// Stack: loop_return_value **=>**
-        Break,
+        /// Stack: **=>** exception
+        Exception,
 
-        /// Sets the `AbruptCompletionRecord` for a delayed continue
+        /// Throw a new `TypeError` exception
         ///
-        /// Operands: Jump Address: u32, Target address: u32,
+        /// Operands: message: u32
         ///
-        /// Stack: loop_return_value **=>**
-        Continue,
+        /// Stack: **=>**
+        ThrowNewTypeError,
 
         /// Pops value converts it to boolean and pushes it back.
         ///
@@ -1377,15 +1356,6 @@ generate_impl! {
         /// Stack: **=>**
         PopEnvironment,
 
-        /// Push loop start marker.
-        ///
-        /// Operands:
-        /// - start: `u32`
-        /// - exit: `u32`
-        ///
-        /// Stack: **=>**
-        LoopStart,
-
         /// Clean up environments when a loop continues.
         ///
         /// Operands:
@@ -1393,27 +1363,6 @@ generate_impl! {
         /// Stack: **=>**
         LoopContinue,
 
-        /// Clean up environments at the end of a loop and return it's value.
-        ///
-        /// Operands:
-        ///
-        /// Stack: **=>** value
-        LoopEnd,
-
-        /// Push labelled start marker.
-        ///
-        /// Operands: Exit Address: u32,
-        ///
-        /// Stack: **=>**
-        LabelledStart,
-
-        /// Clean up environments at the end of a labelled block.
-        ///
-        /// Operands:
-        ///
-        /// Stack: **=>**
-        LabelledEnd,
-
         /// Creates the ForInIterator of an object.
         ///
         /// Stack: object **=>**
@@ -1421,15 +1370,6 @@ generate_impl! {
         /// Iterator Stack: `iterator`
         CreateForInIterator,
 
-        /// Push iterator loop start marker.
-        ///
-        /// Operands:
-        /// - start: `u32`
-        /// - exit: `u32`
-        ///
-        /// Stack: **=>**
-        IteratorLoopStart,
-
         /// Gets the iterator of an object.
         ///
         /// Operands:
@@ -1455,6 +1395,13 @@ generate_impl! {
         /// Iterator Stack: `iterator` **=>** `iterator`
         IteratorNext,
 
+        /// Calls the `next` method of `iterator`, updating its record with the next value.
+        ///
+        /// Operands:
+        ///
+        /// Iterator Stack: `iterator` **=>** `iterator`
+        IteratorNextWithoutPop,
+
         /// Returns `true` if the current iterator is done, or `false` otherwise
         ///
         /// Stack: **=>** done
@@ -1472,14 +1419,21 @@ generate_impl! {
         /// Iterator Stack: iterator **=>** iterator
         IteratorFinishAsyncNext,
 
-        ///  - Gets the `value` property of the current iterator record.
+        /// Gets the `value` property of the current iterator record.
         ///
         /// Stack: **=>** `value`
         ///
         /// Iterator Stack: `iterator` **=>** `iterator`
         IteratorValue,
 
-        ///  - Gets the last iteration result of the current iterator record.
+        /// Gets the `value` property of the current iterator record.
+        ///
+        /// Stack: **=>** `value`
+        ///
+        /// Iterator Stack: `iterator` **=>** `iterator`
+        IteratorValueWithoutPop,
+
+        /// Gets the last iteration result of the current iterator record.
         ///
         /// Stack: **=>** `result`
         ///
@@ -1796,6 +1750,18 @@ generate_impl! {
         Reserved55 => Reserved,
         /// Reserved [`Opcode`].
         Reserved56 => Reserved,
+        /// Reserved [`Opcode`].
+        Reserved57 => Reserved,
+        /// Reserved [`Opcode`].
+        Reserved58 => Reserved,
+        /// Reserved [`Opcode`].
+        Reserved59 => Reserved,
+        /// Reserved [`Opcode`].
+        Reserved60 => Reserved,
+        /// Reserved [`Opcode`].
+        Reserved61 => Reserved,
+        /// Reserved [`Opcode`].
+        Reserved62 => Reserved,
     }
 }
 
diff --git a/boa_engine/src/vm/opcode/pop/mod.rs b/boa_engine/src/vm/opcode/pop/mod.rs
index ffadf549123..875bfed748d 100644
--- a/boa_engine/src/vm/opcode/pop/mod.rs
+++ b/boa_engine/src/vm/opcode/pop/mod.rs
@@ -33,7 +33,6 @@ impl Operation for PopEnvironment {
 
     fn execute(context: &mut Context<'_>) -> JsResult<CompletionType> {
         context.vm.environments.pop();
-        context.vm.frame_mut().dec_frame_env_stack();
         Ok(CompletionType::Normal)
     }
 }
diff --git a/boa_engine/src/vm/opcode/push/environment.rs b/boa_engine/src/vm/opcode/push/environment.rs
index 47ebd68fbfd..462c9930c84 100644
--- a/boa_engine/src/vm/opcode/push/environment.rs
+++ b/boa_engine/src/vm/opcode/push/environment.rs
@@ -22,7 +22,6 @@ impl Operation for PushDeclarativeEnvironment {
             [compile_environments_index as usize]
             .clone();
         context.vm.environments.push_lexical(compile_environment);
-        context.vm.frame_mut().inc_frame_env_stack();
         Ok(CompletionType::Normal)
     }
 }
@@ -67,7 +66,6 @@ impl Operation for PushObjectEnvironment {
         let object = object.to_object(context)?;
 
         context.vm.environments.push_object(object);
-        context.vm.frame_mut().inc_frame_env_stack();
         Ok(CompletionType::Normal)
     }
 }