diff --git a/boa_engine/src/bytecompiler/env.rs b/boa_engine/src/bytecompiler/env.rs
index ffe025a94d3..7d189de9fe7 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(RefCell::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..a58e29853b1 100644
--- a/boa_engine/src/bytecompiler/jump_control.rs
+++ b/boa_engine/src/bytecompiler/jump_control.rs
@@ -9,19 +9,59 @@
 //! [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::Opcode,
+};
 use bitflags::bitflags;
 use boa_interner::Sym;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum JumpRecordKind {
+    Break,
+    Continue,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct JumpRecord {
+    kind: JumpRecordKind,
+    label: Option<Sym>,
+    address: Label,
+    target_index: Option<usize>,
+}
+
+impl JumpRecord {
+    pub(crate) const fn new(
+        kind: JumpRecordKind,
+        label: Option<Sym>,
+        address: Label,
+        target_index: Option<usize>,
+    ) -> Self {
+        Self {
+            kind,
+            label,
+            address,
+            target_index,
+        }
+    }
+
+    pub(crate) const fn label(&self) -> Option<Sym> {
+        self.label
+    }
+
+    pub(crate) const fn target_index(&self) -> Option<usize> {
+        self.target_index
+    }
+}
+
 /// 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) jumps: Vec<JumpRecord>,
+    current_open_environments_count: u32,
 }
 
 bitflags! {
@@ -32,7 +72,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 +80,13 @@ bitflags! {
         ///
         /// This bitflag is inherited if the previous [`JumpControlInfo`].
         const USE_EXPR = 0b0001_0000_0000;
+
+        /// Does the control flow jump (`break` or `continue`) require to special finally code generation.
+        ///
+        /// This is needed for `break` and `continue`s that are in a try statement
+        /// (try or catch blocks, for finally not needed because it is already executing it).
+        ///
+        const REQUIRE_FINALLY_HANDLING = 0b0010_0000_0000;
     }
 }
 
@@ -50,21 +96,18 @@ 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,
         }
     }
-}
 
-/// ---- `JumpControlInfo` Creation Methods ----
-impl JumpControlInfo {
     pub(crate) const fn with_label(mut self, label: Option<Sym>) -> Self {
         self.label = label;
         self
@@ -138,10 +181,6 @@ 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)
     }
@@ -150,10 +189,12 @@ impl JumpControlInfo {
         self.flags.contains(JumpControlInfoFlags::USE_EXPR)
     }
 
+    #[allow(dead_code)]
     pub(crate) const fn iterator_loop(&self) -> bool {
         self.flags.contains(JumpControlInfoFlags::ITERATOR_LOOP)
     }
 
+    #[allow(dead_code)]
     pub(crate) const fn for_await_of_loop(&self) -> bool {
         self.flags.contains(JumpControlInfoFlags::FOR_AWAIT_OF_LOOP)
     }
@@ -172,23 +213,32 @@ impl JumpControlInfo {
         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_break_label(
+        &mut self,
+        label: Option<Sym>,
+        address: Label,
+        final_target: Option<usize>,
+    ) {
+        self.jumps.push(JumpRecord::new(
+            JumpRecordKind::Break,
+            label,
+            address,
+            final_target,
+        ));
     }
 
-    pub(crate) fn push_set_jumps(&mut self, set_jump_label: Label) {
-        self.set_jumps.push(set_jump_label);
+    pub(crate) fn push_continue_label(
+        &mut self,
+        label: Option<Sym>,
+        address: Label,
+        final_target: Option<usize>,
+    ) {
+        self.jumps.push(JumpRecord::new(
+            JumpRecordKind::Continue,
+            label,
+            address,
+            final_target,
+        ));
     }
 }
 
@@ -198,7 +248,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);
     }
 
@@ -242,7 +293,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 +311,30 @@ impl ByteCompiler<'_, '_> {
         let info = self.jump_info.pop().expect("no jump information found");
 
         assert!(info.is_labelled());
+        assert!(info.label().is_some());
+
+        for jump @ JumpRecord {
+            label,
+            kind,
+            address,
+            ..
+        } in &info.jumps
+        {
+            if info.label() == *label {
+                match kind {
+                    JumpRecordKind::Break => self.patch_jump(*address),
+                    JumpRecordKind::Continue => {
+                        self.patch_jump_with_target(*address, info.start_address)
+                    }
+                }
+                continue;
+            }
 
-        for label in info.breaks {
-            self.patch_jump(label);
-        }
-
-        for label in info.try_continues {
-            self.patch_jump_with_target(label, info.start_address);
+            self.jump_info
+                .last_mut()
+                .expect("There should be a previous JumpInfo")
+                .jumps
+                .push(*jump);
         }
     }
     // ---- `IterationStatement`'s `JumpControlInfo` methods ---- //
@@ -278,7 +346,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 +361,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 +376,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 +398,11 @@ 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 JumpRecord { kind, address, .. } in info.jumps {
+            match kind {
+                JumpRecordKind::Break => self.patch_jump(address),
+                JumpRecordKind::Continue => self.patch_jump_with_target(address, start_address),
+            }
         }
     }
 
@@ -348,7 +415,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 +434,17 @@ impl ByteCompiler<'_, '_> {
 
         assert!(info.is_switch());
 
-        for label in info.breaks {
-            self.patch_jump(label);
+        for jump in info.jumps {
+            match jump.kind {
+                JumpRecordKind::Break => self.patch_jump(jump.address),
+                JumpRecordKind::Continue => {
+                    self.jump_info
+                        .last_mut()
+                        .expect("There should be a previous JumpInfo")
+                        .jumps
+                        .push(jump);
+                }
+            }
         }
     }
 
@@ -381,7 +457,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);
@@ -402,68 +478,72 @@ impl ByteCompiler<'_, '_> {
 
         // 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;
-                }
+            for JumpRecord { address, .. } in &info.jumps {
+                self.patch_jump_with_target(*address, try_end);
             }
-        }
 
-        // 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;
+            let (jumps, default) = self.jump_table(info.jumps.len() as u32);
+
+            // Handle breaks in a finally block
+            for (i, label) in jumps.iter().enumerate() {
+                if let Some(jump_info) = self.jump_info.last_mut() {
+                    let jump_record = &info.jumps[i];
+                    let environments_to_pop = info.current_open_environments_count
+                        - jump_info.current_open_environments_count;
+                    let next = if environments_to_pop == 0 {
+                        *label
+                    } else {
+                        let next_index = jump_info.jumps.len();
+                        let is_try_block_and_has_finally =
+                            jump_info.is_try_block() && jump_info.has_finally();
+
+                        self.patch_jump(*label);
+                        for _ in 0..environments_to_pop {
+                            self.emit_opcode(Opcode::PopEnvironment);
+                        }
+
+                        if is_try_block_and_has_finally {
+                            self.emit_push_integer(next_index as i32 + 1);
+                            self.emit_opcode(Opcode::PushFalse);
+                        }
+
+                        self.jump()
+                    };
+
+                    // A target cannot be a try so we append to previous `JumpInfo`.
+                    let jump_info = self.jump_info.last_mut().expect("jump info disapeared");
+                    match jump_record.kind {
+                        JumpRecordKind::Break => jump_info.push_break_label(
+                            jump_record.label(),
+                            next,
+                            jump_record.target_index(),
+                        ),
+                        JumpRecordKind::Continue => jump_info.push_continue_label(
+                            jump_record.label(),
+                            next,
+                            jump_record.target_index(),
+                        ),
+                    }
                 }
             }
-        }
 
-        // 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.patch_jump(default);
+        } else if !info.jumps.is_empty() {
+            // When there is no finally, append to previous `JumpInfo`.
+            self.jump_info
+                .last_mut()
+                .expect("There should be a previous JumpInfo")
+                .jumps
+                .append(&mut info.jumps);
         }
     }
 
-    /// 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);
-
-        new_info.set_in_finally(true);
-
-        self.push_contol_info(new_info, use_expr);
-    }
-
-    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");
-
-        assert!(info.in_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;
-                }
-            }
-        }
-
-        // 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 b372fb0a55c..bee402396e5 100644
--- a/boa_engine/src/bytecompiler/mod.rs
+++ b/boa_engine/src/bytecompiler/mod.rs
@@ -249,6 +249,8 @@ pub struct ByteCompiler<'ctx, 'host> {
     /// The environment that is currently active.
     pub(crate) current_environment: Rc<RefCell<CompileTimeEnvironment>>,
 
+    pub(crate) current_open_environments_count: u32,
+
     pub(crate) code_block_flags: CodeBlockFlags,
 
     literals_map: FxHashMap<Literal, u32>,
@@ -293,6 +295,7 @@ impl<'ctx, 'host> ByteCompiler<'ctx, 'host> {
             this_mode: ThisMode::Global,
             params: FormalParameterList::default(),
             compile_environments: Vec::default(),
+            current_open_environments_count: 0,
             code_block_flags,
 
             literals_map: FxHashMap::default(),
@@ -506,6 +509,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 {
diff --git a/boa_engine/src/bytecompiler/statement/break.rs b/boa_engine/src/bytecompiler/statement/break.rs
index eb51b429cd5..f1d97be4718 100644
--- a/boa_engine/src/bytecompiler/statement/break.rs
+++ b/boa_engine/src/bytecompiler/statement/break.rs
@@ -1,73 +1,54 @@
-use crate::{
-    bytecompiler::{ByteCompiler, JumpControlInfo},
-    vm::Opcode,
-};
+use crate::{bytecompiler::ByteCompiler, vm::Opcode};
 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 target_jump_info_index = self.break_jump_info_target_index(node);
 
-            let (break_label, target_jump_label) =
-                self.emit_opcode_with_two_operands(Opcode::Break);
-
-            if let Some(node_label) = node.label() {
-                let info = self.jump_info_label(node_label);
-                info.push_break_label(target_jump_label);
-
-                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);
+        for i in (target_jump_info_index..self.jump_info.len()).rev() {
+            let count = self.jump_info_open_environment_count(i);
+            for _ in 0..count {
+                self.emit_opcode(Opcode::PopEnvironment);
             }
 
-            let info = self
-                .jump_info
-                .last_mut()
-                .expect("This try block must exist");
-
-            info.push_break_label(break_label);
+            let info = &mut self.jump_info[i];
+            if info.is_try_block() && info.has_finally() {
+                let next_index = info.jumps.len();
 
-            return;
-        }
-
-        // 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;
-        }
+                self.emit_push_integer(next_index as i32 + 1);
+                self.emit_opcode(Opcode::PushFalse);
+                let break_label = self.emit_opcode_with_operand(Opcode::Break);
 
-        let info = self.jump_info_non_labelled();
-        info.push_break_label(break_label);
-        info.push_break_label(target_label);
-    }
+                let info = &mut self.jump_info[i];
+                info.push_break_label(node.label(), break_label, Some(target_jump_info_index));
+                break;
+            }
 
-    fn jump_info_non_labelled(&mut self) -> &mut JumpControlInfo {
-        for info in self.jump_info.iter_mut().rev() {
-            if !info.is_labelled() {
-                return info;
+            if i == target_jump_info_index {
+                let break_label = self.emit_opcode_with_operand(Opcode::Break);
+                let info = &mut self.jump_info[i];
+                info.push_break_label(node.label(), break_label, None);
+                break;
             }
         }
-        panic!("Jump info without label must exist");
     }
 
-    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;
+    fn break_jump_info_target_index(&self, node: Break) -> usize {
+        if let Some(label) = node.label() {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                if info.label() == Some(label) {
+                    return i;
+                }
+            }
+        } else {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                if info.is_loop() || info.is_switch() {
+                    return i;
+                }
             }
         }
-        panic!("Jump info with label must exist");
+
+        unreachable!("There should be a valid break jump target")
     }
 }
diff --git a/boa_engine/src/bytecompiler/statement/continue.rs b/boa_engine/src/bytecompiler/statement/continue.rs
index e6f68e9c5d0..8081de45c7d 100644
--- a/boa_engine/src/bytecompiler/statement/continue.rs
+++ b/boa_engine/src/bytecompiler/statement/continue.rs
@@ -4,115 +4,193 @@ 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();
-
-            // 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;
-                    }
-
-                    if info.iterator_loop() {
-                        iterator_closes.push(info.for_await_of_loop());
-                    }
-                }
+        // 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();
 
-                for r#async in iterator_closes {
-                    self.iterator_close(r#async);
-                }
+        //     // 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();
 
-                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());
-                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;
-                    }
-                }
-                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) {
-                    break;
-                }
+        //         for info in items {
+        //             if info.label() == Some(node_label) {
+        //                 break;
+        //             }
 
-                if info.iterator_loop() {
-                    iterator_closes.push(info.for_await_of_loop());
-                }
+        //             if info.iterator_loop() {
+        //                 iterator_closes.push(info.for_await_of_loop());
+        //             }
+        //         }
+
+        //         for r#async in iterator_closes {
+        //             self.iterator_close(r#async);
+        //         }
+
+        //         let cont_label = self.emit_opcode_with_operand(Opcode::Continue);
+
+        //         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;
+        //                 break;
+        //             } else if found_label && !in_finally_or_has_finally {
+        //                 info.push_try_continue_label(Some(node_label), cont_label);
+        //                 break;
+        //             }
+        //         }
+        //         // if set_continue_as_break {
+        //         //     self.jump_info
+        //         //         .last_mut()
+        //         //         .expect("no jump information found")
+        //         //         .push_break_label(Some(node_label), cont_label);
+        //         // }
+        //     } else {
+        //         // TODO: Add has finally or in finally here
+        //         let cont_label= self.emit_opcode_with_operand(Opcode::Continue);
+        //         // if in_finally_or_has_finally {
+        //         //     self.jump_info
+        //         //         .last_mut()
+        //         //         .expect("Must exist and be a try block")
+        //         //         .push_break_label(None, 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(None, cont_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) {
+        //             break;
+        //         }
+
+        //         if info.iterator_loop() {
+        //             iterator_closes.push(info.for_await_of_loop());
+        //         }
+        //     }
+
+        //     for r#async in iterator_closes {
+        //         self.iterator_close(r#async);
+        //     }
+
+        //     let cont_label = self.emit_opcode_with_operand(Opcode::Continue);
+        //     let loops = self
+        //         .jump_info
+        //         .iter_mut()
+        //         .rev()
+        //         .filter(|info| info.is_loop());
+
+        //     for info in loops {
+        //         if info.label() == Some(node_label) {
+        //             info.push_try_continue_label(Some(node_label), cont_label);
+        //         }
+        //     }
+        // } else {
+        //     let cont_label = self.emit_opcode_with_operand(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(None, cont_label);
+        // }
+
+        // for i in (target_jump_info_index..self.jump_info.len()).rev() {
+        //     let count = self.jump_info_open_environment_count(i);
+        //     for _ in 0..count {
+        //         self.emit_opcode(Opcode::PopEnvironment);
+        //     }
+
+        //     let info = &mut self.jump_info[i];
+        //     if info.is_try_block() && info.has_finally() {
+        //         let next_index = info.breaks.len();
+
+        //         self.emit_push_integer(next_index as i32 + 1);
+        //         self.emit_opcode(Opcode::PushFalse);
+        //         let continue_label = self.emit_opcode_with_operand(Opcode::Continue);
+
+        //         let info = &mut self.jump_info[i];
+        //         info.push_(node.label(), continue_label, Some(target_jump_info_index));
+        //         break;
+        //     }
+
+        //     if i == target_jump_info_index {
+        //         let break_label = self.emit_opcode_with_operand(Opcode::Break);
+        //         let info = &mut self.jump_info[i];
+        //         info.push_break_label(node.label(), break_label, None);
+        //         break;
+        //     }
+        // }
+        let target_jump_info_index = self.continue_jump_info_target_index(node);
+
+        for i in (target_jump_info_index..self.jump_info.len()).rev() {
+            let count = self.jump_info_open_environment_count(i);
+            for _ in 0..count {
+                self.emit_opcode(Opcode::PopEnvironment);
             }
 
-            for r#async in iterator_closes {
+            if i == target_jump_info_index {
+                let continue_label = self.emit_opcode_with_operand(Opcode::Continue);
+                let info = &mut self.jump_info[i];
+                info.push_continue_label(node.label(), continue_label, None);
+                break;
+            }
+
+            let info = &mut self.jump_info[i];
+            if info.is_try_block() && info.has_finally() {
+                let next_index = info.jumps.len();
+
+                self.emit_push_integer(next_index as i32 + 1);
+                self.emit_opcode(Opcode::PushFalse);
+                let continue_label = self.emit_opcode_with_operand(Opcode::Continue);
+
+                let info = &mut self.jump_info[i];
+                info.push_continue_label(
+                    node.label(),
+                    continue_label,
+                    Some(target_jump_info_index),
+                );
+                break;
+            }
+
+            let info = &self.jump_info[i];
+            if info.iterator_loop() {
+                let r#async = info.for_await_of_loop();
                 self.iterator_close(r#async);
             }
+        }
+    }
 
-            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());
-
-            for info in loops {
-                if info.label() == Some(node_label) {
-                    info.push_try_continue_label(cont_label);
-                    info.push_try_continue_label(set_label);
+    fn continue_jump_info_target_index(&self, node: Continue) -> usize {
+        if let Some(label) = node.label() {
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                if info.label() == Some(label) {
+                    return i;
                 }
             }
         } 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);
+            for (i, info) in self.jump_info.iter().enumerate().rev() {
+                if info.is_loop() {
+                    return i;
+                }
+            }
         }
+
+        unreachable!("There should be a valid break jump target")
     }
 }
diff --git a/boa_engine/src/bytecompiler/statement/labelled.rs b/boa_engine/src/bytecompiler/statement/labelled.rs
index 8ae56121872..bab66e8d7a4 100644
--- a/boa_engine/src/bytecompiler/statement/labelled.rs
+++ b/boa_engine/src/bytecompiler/statement/labelled.rs
@@ -41,6 +41,5 @@ 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..79630e18294 100644
--- a/boa_engine/src/bytecompiler/statement/loop.rs
+++ b/boa_engine/src/bytecompiler/statement/loop.rs
@@ -57,7 +57,7 @@ impl ByteCompiler<'_, '_> {
         }
 
         self.push_empty_loop_jump_control(use_expr);
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
+        self.emit_opcode(Opcode::LoopStart);
         let initial_jump = self.jump();
         let start_address = self.next_opcode_location();
 
@@ -81,7 +81,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,8 +100,10 @@ impl ByteCompiler<'_, '_> {
         self.emit(Opcode::Jump, &[start_address]);
 
         self.patch_jump(exit);
-        self.patch_jump(loop_exit);
         self.pop_loop_control_info();
+        if env_labels.is_some() {
+            self.emit_opcode(Opcode::PopEnvironment);
+        }
         self.emit_opcode(Opcode::LoopEnd);
 
         if let Some(env_labels) = env_labels {
@@ -111,7 +112,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 +154,11 @@ 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);
+        self.emit_opcode(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,7 +232,6 @@ 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);
 
@@ -278,7 +276,7 @@ impl ByteCompiler<'_, '_> {
             self.emit_opcode(Opcode::GetIterator);
         }
 
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::IteratorLoopStart);
+        self.emit_opcode(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 +284,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() {
@@ -381,7 +378,6 @@ 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);
 
@@ -394,11 +390,10 @@ impl ByteCompiler<'_, '_> {
         label: Option<Sym>,
         use_expr: bool,
     ) {
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
+        self.emit_opcode(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,7 +403,6 @@ 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);
     }
@@ -419,12 +413,11 @@ impl ByteCompiler<'_, '_> {
         label: Option<Sym>,
         use_expr: bool,
     ) {
-        let (loop_start, loop_exit) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
+        self.emit_opcode(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,7 +431,6 @@ 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/switch.rs b/boa_engine/src/bytecompiler/statement/switch.rs
index 55eae910337..65e57a33a44 100644
--- a/boa_engine/src/bytecompiler/statement/switch.rs
+++ b/boa_engine/src/bytecompiler/statement/switch.rs
@@ -11,11 +11,10 @@ impl ByteCompiler<'_, '_> {
 
         self.block_declaration_instantiation(switch);
 
-        let (start_label, end_label) = self.emit_opcode_with_two_operands(Opcode::LoopStart);
+        self.emit_opcode(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,7 +51,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();
diff --git a/boa_engine/src/bytecompiler/statement/try.rs b/boa_engine/src/bytecompiler/statement/try.rs
index 6f9edfeb230..2e427ec8a0d 100644
--- a/boa_engine/src/bytecompiler/statement/try.rs
+++ b/boa_engine/src/bytecompiler/statement/try.rs
@@ -10,25 +10,38 @@ 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);
-        }
+        let has_finally = t.finally().is_some();
+        let has_catch = t.catch().is_some();
         self.push_try_control_info(t.finally().is_some(), try_start, use_expr);
 
         self.compile_block(t.block(), use_expr);
 
         self.emit_opcode(Opcode::TryEnd);
 
+        if has_finally {
+            self.emit_opcode(Opcode::PushZero);
+            if has_catch {
+                self.emit_opcode(Opcode::PushFalse);
+            } else {
+                self.emit_opcode(Opcode::PushFalse);
+            }
+        }
+
         let finally = self.jump();
         self.patch_jump(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::PushZero);
+            self.emit_opcode(Opcode::PushTrue);
         }
 
         self.patch_jump(finally);
@@ -38,21 +51,25 @@ impl ByteCompiler<'_, '_> {
             // 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);
             // Compile finally statement body
-            self.compile_finally_stmt(finally, finally_end);
+            self.compile_finally_stmt(finally, finally_end, 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
+
         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 +92,33 @@ 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);
+        }
     }
 
-    pub(crate) fn compile_finally_stmt(&mut self, finally: &Finally, finally_end_label: Label) {
+    pub(crate) fn compile_finally_stmt(
+        &mut self,
+        finally: &Finally,
+        finally_end_label: Label,
+        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();
+        let has_throw_exit = self.jump_if_false();
+        if !has_catch {
+            self.emit_opcode(Opcode::Pop);
+        }
+
+        // Rethrow error if error happend!
+        self.emit_opcode(Opcode::ReThrow);
+        self.patch_jump(has_throw_exit);
+
         self.patch_jump(finally_end_label);
-        self.emit_opcode(Opcode::FinallyEnd);
     }
 }
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..6f944a1dd6e 100644
--- a/boa_engine/src/vm/call_frame/mod.rs
+++ b/boa_engine/src/vm/call_frame/mod.rs
@@ -2,8 +2,7 @@
 //!
 //! This module will provides everything needed to implement the `CallFrame`
 
-mod abrupt_record;
-mod env_stack;
+mod try_stack;
 
 use crate::{
     builtins::{iterable::IteratorRecord, promise::PromiseCapability},
@@ -15,8 +14,7 @@ use crate::{
 use boa_gc::{Finalize, Gc, Trace};
 use thin_vec::ThinVec;
 
-pub(crate) use abrupt_record::AbruptCompletionRecord;
-pub(crate) use env_stack::EnvStackEntry;
+pub(crate) use try_stack::TryStackEntry;
 
 /// A `CallFrame` holds the state of a function call.
 #[derive(Clone, Debug, Finalize, Trace)]
@@ -25,13 +23,11 @@ pub struct CallFrame {
     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,
     // 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) try_stack: Vec<TryStackEntry>,
     pub(crate) argument_count: u32,
     #[unsafe_ignore_trace]
     pub(crate) generator_resume_kind: GeneratorResumeKind,
@@ -47,6 +43,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,13 +65,11 @@ 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,
+            try_stack: Vec::default(),
             r#yield: false,
             argument_count: 0,
             generator_resume_kind: GeneratorResumeKind::Normal,
@@ -80,6 +77,7 @@ impl CallFrame {
             async_generator: None,
             iterators: ThinVec::new(),
             binding_stack: Vec::new(),
+            loop_iteration_count: 0,
             return_value: JsValue::undefined(),
         }
     }
@@ -96,25 +94,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/call_frame/try_stack.rs b/boa_engine/src/vm/call_frame/try_stack.rs
new file mode 100644
index 00000000000..9bf537ae993
--- /dev/null
+++ b/boa_engine/src/vm/call_frame/try_stack.rs
@@ -0,0 +1,45 @@
+// TODO(HalidOdat): remove this
+#![allow(dead_code)]
+
+/// The `EnvStackEntry` tracks the environment count and relevant information for the current environment.
+#[derive(Clone, Debug)]
+pub(crate) struct TryStackEntry {
+    catch: u32,
+    finally: u32,
+
+    /// 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,
+
+    env_fp: u32,
+}
+
+impl TryStackEntry {
+    /// Creates a new [`EnvStackEntry`] with the supplied start addresses.
+    pub(crate) const fn new(catch: u32, finally: u32, fp: u32, env_fp: u32) -> Self {
+        Self {
+            catch,
+            finally,
+            fp,
+            env_fp,
+        }
+    }
+
+    pub(crate) const fn catch(&self) -> u32 {
+        self.catch
+    }
+
+    pub(crate) const fn finally(&self) -> u32 {
+        self.finally
+    }
+
+    pub(crate) const fn fp(&self) -> u32 {
+        self.fp
+    }
+
+    pub(crate) const fn env_fp(&self) -> u32 {
+        self.env_fp
+    }
+}
diff --git a/boa_engine/src/vm/code_block.rs b/boa_engine/src/vm/code_block.rs
index c2cf7193c9b..8bca6192c13 100644
--- a/boa_engine/src/vm/code_block.rs
+++ b/boa_engine/src/vm/code_block.rs
@@ -337,10 +337,6 @@ impl CodeBlock {
                 format!("{operand}")
             }
             Opcode::CopyDataProperties
-            | Opcode::Break
-            | Opcode::Continue
-            | Opcode::LoopStart
-            | Opcode::IteratorLoopStart
             | Opcode::TryStart
             | Opcode::GeneratorDelegateNext
             | Opcode::GeneratorDelegateResume => {
@@ -350,6 +346,11 @@ impl CodeBlock {
                 *pc += size_of::<u32>();
                 format!("{operand1}, {operand2}")
             }
+            Opcode::Break | Opcode::Continue => {
+                let operand = self.read::<u32>(*pc);
+                *pc += size_of::<u32>();
+                format!("{operand}")
+            }
             Opcode::TemplateLookup | Opcode::TemplateCreate => {
                 let operand1 = self.read::<u32>(*pc);
                 *pc += size_of::<u32>();
@@ -432,6 +433,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 + 1) {
+                    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>();
@@ -512,14 +528,17 @@ impl CodeBlock {
             | Opcode::ToPropertyKey
             | Opcode::ToBoolean
             | Opcode::Throw
+            | Opcode::ReThrow
+            | Opcode::Exception
             | Opcode::TryEnd
-            | Opcode::FinallyEnd
             | Opcode::This
             | Opcode::Super
             | Opcode::Return
             | Opcode::PopEnvironment
             | Opcode::LoopEnd
             | Opcode::LoopContinue
+            | Opcode::LoopStart
+            | Opcode::IteratorLoopStart
             | Opcode::LabelledEnd
             | Opcode::CreateForInIterator
             | Opcode::GetIterator
@@ -618,9 +637,7 @@ impl CodeBlock {
             | Opcode::Reserved51
             | Opcode::Reserved52
             | Opcode::Reserved53
-            | Opcode::Reserved54
-            | Opcode::Reserved55
-            | Opcode::Reserved56 => unreachable!("Reserved opcodes are unrechable"),
+            | Opcode::Reserved54 => unreachable!("Reserved opcodes are unrechable"),
         }
     }
 }
diff --git a/boa_engine/src/vm/flowgraph/mod.rs b/boa_engine/src/vm/flowgraph/mod.rs
index 6e632d66bb1..04f3032064e 100644
--- a/boa_engine/src/vm/flowgraph/mod.rs
+++ b/boa_engine/src/vm/flowgraph/mod.rs
@@ -138,12 +138,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::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>();
@@ -157,10 +151,8 @@ impl CodeBlock {
                 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}");
+                    let label = format!("{opcode_str} {jump_operand}");
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
                     graph.add_edge(
                         previous_pc,
@@ -171,16 +163,14 @@ impl CodeBlock {
                     );
                 }
                 Opcode::Continue => {
-                    let jump_address = self.read::<u32>(pc);
-                    pc += size_of::<u32>();
-                    let target_operand = self.read::<u32>(pc);
+                    let jump_operand = self.read::<u32>(pc);
                     pc += size_of::<u32>();
 
-                    let label = format!("{opcode_str} {jump_address}, target {target_operand}");
+                    let label = format!("{opcode_str} {jump_operand}");
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::Red);
                     graph.add_edge(
                         previous_pc,
-                        jump_address as usize,
+                        jump_operand as usize,
                         Some("CONTINUE".into()),
                         Color::Red,
                         EdgeStyle::Line,
@@ -496,7 +486,7 @@ impl CodeBlock {
                         returns.push(previous_pc);
                     }
                 }
-                Opcode::Throw => {
+                Opcode::Throw | Opcode::ReThrow => {
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                     if let Some((_try_pc, next, _finally)) = try_entries.last() {
                         graph.add_edge(
@@ -516,6 +506,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
@@ -581,11 +578,12 @@ impl CodeBlock {
                 | Opcode::DeleteSuperThrow
                 | Opcode::ToPropertyKey
                 | Opcode::ToBoolean
-                | Opcode::FinallyEnd
                 | Opcode::This
                 | Opcode::Super
                 | Opcode::LoopEnd
                 | Opcode::LoopContinue
+                | Opcode::LoopStart
+                | Opcode::IteratorLoopStart
                 | Opcode::LabelledEnd
                 | Opcode::CreateForInIterator
                 | Opcode::GetIterator
@@ -629,6 +627,7 @@ 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);
@@ -708,9 +707,7 @@ impl CodeBlock {
                 | Opcode::Reserved51
                 | Opcode::Reserved52
                 | Opcode::Reserved53
-                | Opcode::Reserved54
-                | Opcode::Reserved55
-                | Opcode::Reserved56 => unreachable!("Reserved opcodes are unrechable"),
+                | Opcode::Reserved54 => unreachable!("Reserved opcodes are unrechable"),
             }
         }
 
diff --git a/boa_engine/src/vm/mod.rs b/boa_engine/src/vm/mod.rs
index 27f81aaced3..7f99502dc13 100644
--- a/boa_engine/src/vm/mod.rs
+++ b/boa_engine/src/vm/mod.rs
@@ -312,10 +312,9 @@ impl Context<'_> {
                         }
                     }
 
-                    self.vm.err = Some(err);
+                    self.vm.err = Some(err.clone());
 
-                    // 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");
 
@@ -359,11 +358,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
diff --git a/boa_engine/src/vm/opcode/control_flow/break.rs b/boa_engine/src/vm/opcode/control_flow/break.rs
index f940fb77bb6..7627551b12c 100644
--- a/boa_engine/src/vm/opcode/control_flow/break.rs
+++ b/boa_engine/src/vm/opcode/control_flow/break.rs
@@ -1,5 +1,5 @@
 use crate::{
-    vm::{call_frame::AbruptCompletionRecord, opcode::Operation, CompletionType},
+    vm::{opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
@@ -15,37 +15,6 @@ impl Operation for 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;
diff --git a/boa_engine/src/vm/opcode/control_flow/continue.rs b/boa_engine/src/vm/opcode/control_flow/continue.rs
index be97fedc237..c365c62dc73 100644
--- a/boa_engine/src/vm/opcode/control_flow/continue.rs
+++ b/boa_engine/src/vm/opcode/control_flow/continue.rs
@@ -1,5 +1,5 @@
 use crate::{
-    vm::{call_frame::AbruptCompletionRecord, opcode::Operation, CompletionType},
+    vm::{opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
@@ -19,48 +19,7 @@ impl Operation for 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
index f3271ea124b..dabf5e1c8cc 100644
--- a/boa_engine/src/vm/opcode/control_flow/finally.rs
+++ b/boa_engine/src/vm/opcode/control_flow/finally.rs
@@ -1,6 +1,6 @@
 use crate::{
     vm::{opcode::Operation, CompletionType},
-    Context, JsError, JsResult,
+    Context, JsResult,
 };
 
 /// `FinallyStart` implements the Opcode Operation for `Opcode::FinallyStart`
@@ -15,16 +15,7 @@ impl Operation for 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);
+        let _exit = context.vm.read::<u32>();
         Ok(CompletionType::Normal)
     }
 }
@@ -40,108 +31,108 @@ 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_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();
-            }
-        }
+    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_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
index fac8c1aeb16..afc8e96d8be 100644
--- a/boa_engine/src/vm/opcode/control_flow/labelled.rs
+++ b/boa_engine/src/vm/opcode/control_flow/labelled.rs
@@ -1,5 +1,5 @@
 use crate::{
-    vm::{call_frame::EnvStackEntry, opcode::Operation, CompletionType},
+    vm::{opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
@@ -15,13 +15,7 @@ impl Operation for 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());
+        let _end = context.vm.read::<u32>();
         Ok(CompletionType::Normal)
     }
 }
@@ -37,19 +31,7 @@ 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);
-
+    fn execute(_context: &mut Context<'_>) -> JsResult<CompletionType> {
         Ok(CompletionType::Normal)
     }
 }
diff --git a/boa_engine/src/vm/opcode/control_flow/return.rs b/boa_engine/src/vm/opcode/control_flow/return.rs
index b44a7f05583..114fa4eea82 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,38 +14,38 @@ 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;
-            }
+    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;
-            }
+        //     env_to_pop += env_entry.env_num();
+        //     if env_entry.is_global_env() {
+        //         break;
+        //     }
 
-            context.vm.frame_mut().env_stack.pop();
-        }
+        //     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 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);
+        // 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);
-        }
+        // if let Some(finally) = finally_address {
+        //     context.vm.frame_mut().pc = finally;
+        //     return Ok(CompletionType::Normal);
+        // }
 
         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..e43560cd538 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,165 +15,229 @@ 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);
+        let error = JsError::from_opaque(context.vm.pop());
+        context.vm.err = Some(error);
+
+        if let Some(try_entry) = context.vm.frame_mut().try_stack.pop() {
+            let catch_address = try_entry.catch();
+            let env_fp = try_entry.env_fp() as usize;
+            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);
         }
 
-        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;
-        }
+        Ok(CompletionType::Throw)
+        // };
+
+        // // 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())
+        // {
+        //     // TODO: handle this
+        //     //
+        //     // 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 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 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();
+        //     }
+
+        //     // TODo: handle this.
+        //     //
+        //     // 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.
 
-        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);
+        //     context.vm.frame_mut().pc = address;
+        //     let err = error.to_opaque(context);
+        //     context.vm.push(err);
+        //     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));
+        //     }
+        // }
+        // context.vm.err.take();
+
+        // context.vm.err = Some(error);
+        // 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");
+
+        if let Some(try_entry) = context.vm.frame_mut().try_stack.pop() {
+            let catch_address = try_entry.catch();
+            let env_fp = try_entry.env_fp() as usize;
+            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);
         }
+        return Ok(CompletionType::Throw);
+    }
+}
 
-        // 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));
-            }
-        }
-        context.vm.err.take();
+/// `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;
 
-        context.vm.err = Some(error);
-        Ok(CompletionType::Throw)
+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!("")
     }
 }
 
diff --git a/boa_engine/src/vm/opcode/control_flow/try.rs b/boa_engine/src/vm/opcode/control_flow/try.rs
index b79b6dc10cb..a1cac85d933 100644
--- a/boa_engine/src/vm/opcode/control_flow/try.rs
+++ b/boa_engine/src/vm/opcode/control_flow/try.rs
@@ -1,5 +1,5 @@
 use crate::{
-    vm::{call_frame::EnvStackEntry, opcode::Operation, CompletionType},
+    vm::{call_frame::TryStackEntry, opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
@@ -18,22 +18,13 @@ impl Operation for TryStart {
         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;
-
+        let env_fp = context.vm.environments.len() as u32;
         context
             .vm
             .frame_mut()
-            .env_stack
-            .push(EnvStackEntry::new(catch, finally).with_try_flag(fp));
+            .try_stack
+            .push(TryStackEntry::new(catch, finally, fp, env_fp));
 
         Ok(CompletionType::Normal)
     }
@@ -51,17 +42,12 @@ impl Operation for 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);
+        context
+            .vm
+            .frame_mut()
+            .try_stack
+            .pop()
+            .expect("There should be a try entry");
 
         Ok(CompletionType::Normal)
     }
diff --git a/boa_engine/src/vm/opcode/iteration/loop_ops.rs b/boa_engine/src/vm/opcode/iteration/loop_ops.rs
index ef694913006..58e8cc64a50 100644
--- a/boa_engine/src/vm/opcode/iteration/loop_ops.rs
+++ b/boa_engine/src/vm/opcode/iteration/loop_ops.rs
@@ -1,6 +1,6 @@
 use crate::JsNativeError;
 use crate::{
-    vm::{call_frame::EnvStackEntry, opcode::Operation, CompletionType},
+    vm::{opcode::Operation, CompletionType},
     Context, JsResult,
 };
 
@@ -15,14 +15,7 @@ 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);
+    fn execute(_context: &mut Context<'_>) -> JsResult<CompletionType> {
         Ok(CompletionType::Normal)
     }
 }
@@ -38,13 +31,7 @@ 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);
+    fn execute(_context: &mut Context<'_>) -> JsResult<CompletionType> {
         Ok(CompletionType::Normal)
     }
 }
@@ -61,31 +48,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 env_num = env.env_num();
-        env.clear_env_num();
+        let previous_iteration_count = context.vm.frame_mut().loop_iteration_count;
 
-        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);
+        context.vm.frame_mut().loop_iteration_count = previous_iteration_count.wrapping_add(1);
 
         Ok(CompletionType::Normal)
     }
@@ -102,19 +74,7 @@ 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);
-
+    fn execute(_context: &mut Context<'_>) -> JsResult<CompletionType> {
         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..bdeaf64865e 100644
--- a/boa_engine/src/vm/opcode/mod.rs
+++ b/boa_engine/src/vm/opcode/mod.rs
@@ -1117,6 +1117,13 @@ generate_impl! {
         /// Stack: value **=>** value
         JumpIfNullOrUndefined,
 
+        /// Jump table
+        ///
+        /// Operands: count: `u32`, default: `u32`, address: `u32` * count
+        ///
+        /// Stack: value **=>**
+        JumpTable,
+
         /// Throw exception
         ///
         /// Operands:
@@ -1124,6 +1131,20 @@ generate_impl! {
         /// Stack: value **=>**
         Throw,
 
+        /// Rethrow thrown exception
+        ///
+        /// Operands:
+        ///
+        /// Stack: **=>**
+        ReThrow,
+
+        /// Get the thrown exception and push on the stack.
+        ///
+        /// Operands:
+        ///
+        /// Stack: **=>** exception
+        Exception,
+
         /// Throw a new `TypeError` exception
         ///
         /// Operands: message: u32
@@ -1152,25 +1173,18 @@ generate_impl! {
         /// Stack: **=>**
         FinallyStart,
 
-        /// End of a finally block.
+        /// Unconditional Jump
         ///
-        /// Operands:
+        /// Operands: Jump Address: u32
         ///
         /// Stack: **=>**
-        FinallyEnd,
-
-        /// Jumps to a target location and pops the environments involved.
-        ///
-        /// Operands: Jump Address: u32, Target address: u32
-        ///
-        /// Stack: loop_return_value **=>**
         Break,
 
-        /// Sets the `AbruptCompletionRecord` for a delayed continue
+        /// Unconditional Jump
         ///
-        /// Operands: Jump Address: u32, Target address: u32,
+        /// Operands: Jump Address: u32
         ///
-        /// Stack: loop_return_value **=>**
+        /// Stack: **=>**
         Continue,
 
         /// Pops value converts it to boolean and pushes it back.
@@ -1377,11 +1391,7 @@ generate_impl! {
         /// Stack: **=>**
         PopEnvironment,
 
-        /// Push loop start marker.
-        ///
-        /// Operands:
-        /// - start: `u32`
-        /// - exit: `u32`
+        /// Loop start marker.
         ///
         /// Stack: **=>**
         LoopStart,
@@ -1792,10 +1802,6 @@ generate_impl! {
         Reserved53 => Reserved,
         /// Reserved [`Opcode`].
         Reserved54 => Reserved,
-        /// Reserved [`Opcode`].
-        Reserved55 => Reserved,
-        /// Reserved [`Opcode`].
-        Reserved56 => 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)
     }
 }