From 25b798275baada2f090fbe21908a0874e541c044 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 13:09:16 +0200
Subject: [PATCH 01/15] rename InstructionIdx -> Instr

---
 crates/wasmi/src/engine/bytecode/utils.rs     | 12 ++++-----
 .../src/engine/func_builder/inst_builder.rs   | 25 ++++++++-----------
 crates/wasmi/src/engine/func_builder/mod.rs   |  6 ++---
 crates/wasmi/src/engine/mod.rs                |  2 +-
 crates/wasmi/src/module/tests.rs              |  7 ++----
 5 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/crates/wasmi/src/engine/bytecode/utils.rs b/crates/wasmi/src/engine/bytecode/utils.rs
index e4bdd4848b..cbacc16c2e 100644
--- a/crates/wasmi/src/engine/bytecode/utils.rs
+++ b/crates/wasmi/src/engine/bytecode/utils.rs
@@ -1,4 +1,4 @@
-use super::super::super::engine::InstructionIdx;
+use super::super::super::engine::Instr;
 use core::fmt::Display;
 
 /// Defines how many stack values are going to be dropped and kept after branching.
@@ -72,19 +72,19 @@ impl DropKeep {
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct Target {
     /// The destination program counter.
-    dst_pc: InstructionIdx,
+    dst_pc: Instr,
     /// How many values on the stack need to be dropped and kept.
     drop_keep: DropKeep,
 }
 
 impl Target {
     /// Creates a new `wasmi` branching target.
-    pub fn new(dst_pc: InstructionIdx, drop_keep: DropKeep) -> Self {
+    pub fn new(dst_pc: Instr, drop_keep: DropKeep) -> Self {
         Self { dst_pc, drop_keep }
     }
 
     /// Returns the destination program counter (as index).
-    pub fn destination_pc(self) -> InstructionIdx {
+    pub fn destination_pc(self) -> Instr {
         self.dst_pc
     }
 
@@ -93,10 +93,10 @@ impl Target {
     /// # Panics
     ///
     /// If the old destination program counter was not [`InstructionIdx::INVALID`].
-    pub fn update_destination_pc(&mut self, new_destination_pc: InstructionIdx) {
+    pub fn update_destination_pc(&mut self, new_destination_pc: Instr) {
         assert_eq!(
             self.destination_pc(),
-            InstructionIdx::INVALID,
+            Instr::INVALID,
             "can only update the destination pc of a target with an invalid \
             destination pc but found a valid one: {:?}",
             self.destination_pc(),
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 26462b9c40..db6ac3f89e 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -7,9 +7,9 @@ use core::mem;
 /// A reference to an instruction of the partially
 /// constructed function body of the [`InstructionsBuilder`].
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct InstructionIdx(u32);
+pub struct Instr(u32);
 
-impl InstructionIdx {
+impl Instr {
     /// An invalid instruction index.
     ///
     /// # Note
@@ -58,7 +58,7 @@ enum Label {
     /// # Note
     ///
     /// A fully resolved label no longer required knowledge about its uses.
-    Resolved(InstructionIdx),
+    Resolved(Instr),
 }
 
 impl Default for Label {
@@ -75,12 +75,9 @@ pub struct LabelIdx(pub(crate) usize);
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum Reloc {
     /// Patch the target of the `br`, `br_eqz` or `br_nez` instruction.
-    Br { inst_idx: InstructionIdx },
+    Br { inst_idx: Instr },
     /// Patch the specified target index inside of a Wasm `br_table` instruction.
-    BrTable {
-        inst_idx: InstructionIdx,
-        target_idx: usize,
-    },
+    BrTable { inst_idx: Instr, target_idx: usize },
 }
 
 /// The relative depth of a Wasm branching target.
@@ -120,8 +117,8 @@ impl InstructionsBuilder {
     }
 
     /// Returns the current instruction pointer as index.
-    pub fn current_pc(&self) -> InstructionIdx {
-        InstructionIdx::from_usize(self.insts.len())
+    pub fn current_pc(&self) -> Instr {
+        Instr::from_usize(self.insts.len())
     }
 
     /// Creates a new unresolved label and returns an index to it.
@@ -188,7 +185,7 @@ impl InstructionsBuilder {
     ///
     /// If resolution fails puts a placeholder into the respective label
     /// and push the new user for later resolution to take place.
-    pub fn try_resolve_label<F>(&mut self, label: LabelIdx, reloc_provider: F) -> InstructionIdx
+    pub fn try_resolve_label<F>(&mut self, label: LabelIdx, reloc_provider: F) -> Instr
     where
         F: FnOnce() -> Reloc,
     {
@@ -196,7 +193,7 @@ impl InstructionsBuilder {
             Label::Resolved(dst_pc) => *dst_pc,
             Label::Unresolved { uses } => {
                 uses.push(reloc_provider());
-                InstructionIdx::INVALID
+                Instr::INVALID
             }
         }
     }
@@ -204,14 +201,14 @@ impl InstructionsBuilder {
     /// Pushes the internal instruction bytecode to the [`InstructionsBuilder`].
     ///
     /// Returns an [`InstructionIdx`] to refer to the pushed instruction.
-    pub fn push_inst(&mut self, inst: Instruction) -> InstructionIdx {
+    pub fn push_inst(&mut self, inst: Instruction) -> Instr {
         let idx = self.current_pc();
         self.insts.push(inst);
         idx
     }
 
     /// Allows to patch the branch target of branch instructions.
-    pub fn patch_relocation(&mut self, reloc: Reloc, dst_pc: InstructionIdx) {
+    pub fn patch_relocation(&mut self, reloc: Reloc, dst_pc: Instr) {
         match reloc {
             Reloc::Br { inst_idx } => match &mut self.insts[inst_idx.into_usize()] {
                 Instruction::Br(target)
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index 51e739b227..99609a6d8d 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -21,7 +21,7 @@ use self::{
 };
 pub use self::{
     error::TranslationError,
-    inst_builder::{InstructionIdx, InstructionsBuilder, LabelIdx, RelativeDepth, Reloc},
+    inst_builder::{Instr, InstructionsBuilder, LabelIdx, RelativeDepth, Reloc},
 };
 use super::{DropKeep, FuncBody, Instruction, Target};
 use crate::{
@@ -183,9 +183,9 @@ impl<'parser> FuncBuilder<'parser> {
     /// Try to resolve the given label.
     ///
     /// In case the label cannot yet be resolved register the [`Reloc`] as its user.
-    fn try_resolve_label<F>(&mut self, label: LabelIdx, reloc_provider: F) -> InstructionIdx
+    fn try_resolve_label<F>(&mut self, label: LabelIdx, reloc_provider: F) -> Instr
     where
-        F: FnOnce(InstructionIdx) -> Reloc,
+        F: FnOnce(Instr) -> Reloc,
     {
         let pc = self.alloc.inst_builder.current_pc();
         self.alloc
diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
index d847fdde36..e8b3e19ed1 100644
--- a/crates/wasmi/src/engine/mod.rs
+++ b/crates/wasmi/src/engine/mod.rs
@@ -27,7 +27,7 @@ pub use self::{
     func_builder::{
         FuncBuilder,
         FunctionBuilderAllocations,
-        InstructionIdx,
+        Instr,
         LabelIdx,
         RelativeDepth,
         Reloc,
diff --git a/crates/wasmi/src/module/tests.rs b/crates/wasmi/src/module/tests.rs
index bcc37fc489..add1e00601 100644
--- a/crates/wasmi/src/module/tests.rs
+++ b/crates/wasmi/src/module/tests.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::{
-    engine::{bytecode::Instruction, DropKeep, InstructionIdx, Target},
+    engine::{bytecode::Instruction, DropKeep, Instr, Target},
     Engine,
 };
 
@@ -294,10 +294,7 @@ fn drop_locals() {
 
 macro_rules! target {
     ( $inst_idx:expr, drop: $drop:expr, keep: $keep:expr ) => {
-        Target::new(
-            InstructionIdx::from_usize($inst_idx),
-            drop_keep($drop, $keep),
-        )
+        Target::new(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
     };
 }
 

From 704139950fd4b55412b20d5f958dc92b05fabf8b Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 13:10:45 +0200
Subject: [PATCH 02/15] rename LabelIdx -> LabelRef

---
 .../src/engine/func_builder/control_frame.rs  | 34 +++++++++----------
 .../src/engine/func_builder/inst_builder.rs   | 14 ++++----
 crates/wasmi/src/engine/func_builder/mod.rs   |  6 ++--
 crates/wasmi/src/engine/mod.rs                |  2 +-
 4 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/crates/wasmi/src/engine/func_builder/control_frame.rs b/crates/wasmi/src/engine/func_builder/control_frame.rs
index 7aaac7958c..4917012464 100644
--- a/crates/wasmi/src/engine/func_builder/control_frame.rs
+++ b/crates/wasmi/src/engine/func_builder/control_frame.rs
@@ -1,4 +1,4 @@
-use crate::{engine::LabelIdx, module::BlockType};
+use crate::{engine::LabelRef, module::BlockType};
 
 /// A Wasm `block` control flow frame.
 #[derive(Debug, Copy, Clone)]
@@ -8,12 +8,12 @@ pub struct BlockControlFrame {
     /// The value stack height upon entering the [`BlockControlFrame`].
     stack_height: u32,
     /// Label representing the end of the [`BlockControlFrame`].
-    end_label: LabelIdx,
+    end_label: LabelRef,
 }
 
 impl BlockControlFrame {
     /// Creates a new [`BlockControlFrame`].
-    pub fn new(block_type: BlockType, end_label: LabelIdx, stack_height: u32) -> Self {
+    pub fn new(block_type: BlockType, end_label: LabelRef, stack_height: u32) -> Self {
         Self {
             block_type,
             stack_height,
@@ -26,12 +26,12 @@ impl BlockControlFrame {
     /// # Note
     ///
     /// Branches to [`BlockControlFrame`] jump to the end of the frame.
-    pub fn branch_destination(&self) -> LabelIdx {
+    pub fn branch_destination(&self) -> LabelRef {
         self.end_label
     }
 
     /// Returns the label to the end of the [`BlockControlFrame`].
-    pub fn end_label(&self) -> LabelIdx {
+    pub fn end_label(&self) -> LabelRef {
         self.end_label
     }
 
@@ -54,12 +54,12 @@ pub struct LoopControlFrame {
     /// The value stack height upon entering the [`LoopControlFrame`].
     stack_height: u32,
     /// Label representing the head of the [`LoopControlFrame`].
-    head_label: LabelIdx,
+    head_label: LabelRef,
 }
 
 impl LoopControlFrame {
     /// Creates a new [`LoopControlFrame`].
-    pub fn new(block_type: BlockType, head_label: LabelIdx, stack_height: u32) -> Self {
+    pub fn new(block_type: BlockType, head_label: LabelRef, stack_height: u32) -> Self {
         Self {
             block_type,
             stack_height,
@@ -72,7 +72,7 @@ impl LoopControlFrame {
     /// # Note
     ///
     /// Branches to [`LoopControlFrame`] jump to the head of the loop.
-    pub fn branch_destination(&self) -> LabelIdx {
+    pub fn branch_destination(&self) -> LabelRef {
         self.head_label
     }
 
@@ -95,9 +95,9 @@ pub struct IfControlFrame {
     /// The value stack height upon entering the [`IfControlFrame`].
     stack_height: u32,
     /// Label representing the end of the [`IfControlFrame`].
-    end_label: LabelIdx,
+    end_label: LabelRef,
     /// Label representing the optional `else` branch of the [`IfControlFrame`].
-    else_label: LabelIdx,
+    else_label: LabelRef,
     /// End of `then` branch is reachable.
     ///
     /// # Note
@@ -116,8 +116,8 @@ impl IfControlFrame {
     /// Creates a new [`IfControlFrame`].
     pub fn new(
         block_type: BlockType,
-        end_label: LabelIdx,
-        else_label: LabelIdx,
+        end_label: LabelRef,
+        else_label: LabelRef,
         stack_height: u32,
     ) -> Self {
         assert_ne!(
@@ -138,17 +138,17 @@ impl IfControlFrame {
     /// # Note
     ///
     /// Branches to [`IfControlFrame`] jump to the end of the if and else frame.
-    pub fn branch_destination(&self) -> LabelIdx {
+    pub fn branch_destination(&self) -> LabelRef {
         self.end_label
     }
 
     /// Returns the label to the end of the [`IfControlFrame`].
-    pub fn end_label(&self) -> LabelIdx {
+    pub fn end_label(&self) -> LabelRef {
         self.end_label
     }
 
     /// Returns the label to the optional `else` of the [`IfControlFrame`].
-    pub fn else_label(&self) -> LabelIdx {
+    pub fn else_label(&self) -> LabelRef {
         self.else_label
     }
 
@@ -259,7 +259,7 @@ impl ControlFrame {
     }
 
     /// Returns the label for the branch destination of the [`ControlFrame`].
-    pub fn branch_destination(&self) -> LabelIdx {
+    pub fn branch_destination(&self) -> LabelRef {
         match self {
             Self::Block(frame) => frame.branch_destination(),
             Self::Loop(frame) => frame.branch_destination(),
@@ -276,7 +276,7 @@ impl ControlFrame {
     /// All [`ControlFrame`] kinds have it except [`ControlFrame::Loop`].
     /// In order to a [`ControlFrame::Loop`] to branch outside it is required
     /// to be wrapped in another control frame such as [`ControlFrame::Block`].
-    pub fn end_label(&self) -> LabelIdx {
+    pub fn end_label(&self) -> LabelRef {
         match self {
             Self::Block(frame) => frame.end_label(),
             Self::If(frame) => frame.end_label(),
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index db6ac3f89e..1632a89456 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -69,7 +69,7 @@ impl Default for Label {
 
 /// A unique label identifier.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct LabelIdx(pub(crate) usize);
+pub struct LabelRef(pub(crate) usize);
 
 /// A relocation entry that specifies.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -122,14 +122,14 @@ impl InstructionsBuilder {
     }
 
     /// Creates a new unresolved label and returns an index to it.
-    pub fn new_label(&mut self) -> LabelIdx {
-        let idx = LabelIdx(self.labels.len());
+    pub fn new_label(&mut self) -> LabelRef {
+        let idx = LabelRef(self.labels.len());
         self.labels.push(Label::default());
         idx
     }
 
     /// Returns `true` if `label` has been resolved.
-    fn is_resolved(&self, label: LabelIdx) -> bool {
+    fn is_resolved(&self, label: LabelRef) -> bool {
         if let Label::Resolved(_) = &self.labels[label.0] {
             return true;
         }
@@ -145,7 +145,7 @@ impl InstructionsBuilder {
     /// This is used at a position of the Wasm bytecode where it is clear that
     /// the given label can be resolved properly.
     /// This usually takes place when encountering the Wasm `End` operand for example.
-    pub fn resolve_label_if_unresolved(&mut self, label: LabelIdx) {
+    pub fn resolve_label_if_unresolved(&mut self, label: LabelRef) {
         if self.is_resolved(label) {
             // Nothing to do in this case.
             return;
@@ -164,7 +164,7 @@ impl InstructionsBuilder {
     /// # Panics
     ///
     /// If the label has already been resolved.
-    pub fn resolve_label(&mut self, label: LabelIdx) {
+    pub fn resolve_label(&mut self, label: LabelRef) {
         let dst_pc = self.current_pc();
         let old_label = mem::replace(&mut self.labels[label.0], Label::Resolved(dst_pc));
         match old_label {
@@ -185,7 +185,7 @@ impl InstructionsBuilder {
     ///
     /// If resolution fails puts a placeholder into the respective label
     /// and push the new user for later resolution to take place.
-    pub fn try_resolve_label<F>(&mut self, label: LabelIdx, reloc_provider: F) -> Instr
+    pub fn try_resolve_label<F>(&mut self, label: LabelRef, reloc_provider: F) -> Instr
     where
         F: FnOnce() -> Reloc,
     {
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index 99609a6d8d..d91596ce86 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -21,7 +21,7 @@ use self::{
 };
 pub use self::{
     error::TranslationError,
-    inst_builder::{Instr, InstructionsBuilder, LabelIdx, RelativeDepth, Reloc},
+    inst_builder::{Instr, InstructionsBuilder, LabelRef, RelativeDepth, Reloc},
 };
 use super::{DropKeep, FuncBody, Instruction, Target};
 use crate::{
@@ -183,7 +183,7 @@ impl<'parser> FuncBuilder<'parser> {
     /// Try to resolve the given label.
     ///
     /// In case the label cannot yet be resolved register the [`Reloc`] as its user.
-    fn try_resolve_label<F>(&mut self, label: LabelIdx, reloc_provider: F) -> Instr
+    fn try_resolve_label<F>(&mut self, label: LabelRef, reloc_provider: F) -> Instr
     where
         F: FnOnce(Instr) -> Reloc,
     {
@@ -356,7 +356,7 @@ impl<'parser> FuncBuilder<'parser> {
 #[derive(Debug)]
 pub enum AcquiredTarget {
     /// The branch jumps to the label.
-    Branch(LabelIdx, DropKeep),
+    Branch(LabelRef, DropKeep),
     /// The branch returns to the caller.
     ///
     /// # Note
diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
index e8b3e19ed1..1023bfa515 100644
--- a/crates/wasmi/src/engine/mod.rs
+++ b/crates/wasmi/src/engine/mod.rs
@@ -28,7 +28,7 @@ pub use self::{
         FuncBuilder,
         FunctionBuilderAllocations,
         Instr,
-        LabelIdx,
+        LabelRef,
         RelativeDepth,
         Reloc,
         TranslationError,

From 559376e0507a30c248d47e3689c7ff8ddd206218 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 13:13:49 +0200
Subject: [PATCH 03/15] rename some label methods

---
 crates/wasmi/src/engine/func_builder/inst_builder.rs | 6 +++---
 crates/wasmi/src/engine/func_builder/mod.rs          | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 1632a89456..12a1d5e73b 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -145,12 +145,12 @@ impl InstructionsBuilder {
     /// This is used at a position of the Wasm bytecode where it is clear that
     /// the given label can be resolved properly.
     /// This usually takes place when encountering the Wasm `End` operand for example.
-    pub fn resolve_label_if_unresolved(&mut self, label: LabelRef) {
+    pub fn pin_label_if_unpinned(&mut self, label: LabelRef) {
         if self.is_resolved(label) {
             // Nothing to do in this case.
             return;
         }
-        self.resolve_label(label);
+        self.pin_label(label);
     }
 
     /// Resolve the label at the current instruction position.
@@ -164,7 +164,7 @@ impl InstructionsBuilder {
     /// # Panics
     ///
     /// If the label has already been resolved.
-    pub fn resolve_label(&mut self, label: LabelRef) {
+    pub fn pin_label(&mut self, label: LabelRef) {
         let dst_pc = self.current_pc();
         let old_label = mem::replace(&mut self.labels[label.0], Label::Resolved(dst_pc));
         match old_label {
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index d91596ce86..f02fd2e3bf 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -444,7 +444,7 @@ impl<'parser> FuncBuilder<'parser> {
         if self.is_reachable() {
             let stack_height = self.frame_stack_height(block_type);
             let header = self.alloc.inst_builder.new_label();
-            self.alloc.inst_builder.resolve_label(header);
+            self.alloc.inst_builder.pin_label(header);
             self.alloc.control_frames.push_frame(LoopControlFrame::new(
                 block_type,
                 header,
@@ -528,7 +528,7 @@ impl<'parser> FuncBuilder<'parser> {
             self.alloc.inst_builder.push_inst(Instruction::Br(target));
         }
         // Now resolve labels for the instructions of the `else` block
-        self.alloc.inst_builder.resolve_label(if_frame.else_label());
+        self.alloc.inst_builder.pin_label(if_frame.else_label());
         // We need to reset the value stack to exactly how it has been
         // when entering the `if` in the first place so that the `else`
         // block has the same parameters on top of the stack.
@@ -552,12 +552,12 @@ impl<'parser> FuncBuilder<'parser> {
             //       in case there was an `Else` block.
             self.alloc
                 .inst_builder
-                .resolve_label_if_unresolved(if_frame.else_label());
+                .pin_label_if_unpinned(if_frame.else_label());
         }
         if frame.is_reachable() && !matches!(frame.kind(), ControlFrameKind::Loop) {
             // At this point we can resolve the `End` labels.
             // Note that `loop` control frames do not have an `End` label.
-            self.alloc.inst_builder.resolve_label(frame.end_label());
+            self.alloc.inst_builder.pin_label(frame.end_label());
         }
         // These bindings are required because of borrowing issues.
         let frame_reachable = frame.is_reachable();

From 72a6416e09e5038b13a54278f7adef97b9fc1d52 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 13:37:55 +0200
Subject: [PATCH 04/15] split Instruction into IrInstruction and
 ExecInstruction

We have not yet introduced an actual difference between them in this commit.
---
 crates/wasmi/src/engine/bytecode/mod.rs       |  29 ++-
 crates/wasmi/src/engine/bytecode/tests.rs     |   3 +-
 crates/wasmi/src/engine/code_map.rs           |  12 +-
 crates/wasmi/src/engine/executor.rs           |  25 ++-
 .../src/engine/func_builder/inst_builder.rs   | 202 +++++++++++++++++-
 crates/wasmi/src/engine/func_builder/mod.rs   |  31 ++-
 crates/wasmi/src/engine/mod.rs                |  12 +-
 crates/wasmi/src/module/tests.rs              |   6 +-
 8 files changed, 281 insertions(+), 39 deletions(-)

diff --git a/crates/wasmi/src/engine/bytecode/mod.rs b/crates/wasmi/src/engine/bytecode/mod.rs
index 8d9a9d2642..a44209281f 100644
--- a/crates/wasmi/src/engine/bytecode/mod.rs
+++ b/crates/wasmi/src/engine/bytecode/mod.rs
@@ -15,8 +15,15 @@ pub use self::utils::{
     SignatureIdx,
     Target,
 };
+use core::fmt::Debug;
 use wasmi_core::UntypedValue;
 
+/// Internal types of an [`Instruction`] type.
+pub trait InstructionTypes {
+    /// A branching target.
+    type Target: Debug + Copy + Clone + PartialEq + Eq;
+}
+
 /// The internal `wasmi` bytecode that is stored for Wasm functions.
 ///
 /// # Note
@@ -25,14 +32,17 @@ use wasmi_core::UntypedValue;
 ///
 /// For example the `BrTable` instruction is unrolled into separate instructions
 /// each representing either the `BrTable` head or one of its branching targets.
-#[derive(Copy, Debug, Clone, PartialEq, Eq)]
-pub enum Instruction {
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Instruction<T>
+where
+    T: InstructionTypes,
+{
     LocalGet { local_depth: LocalDepth },
     LocalSet { local_depth: LocalDepth },
     LocalTee { local_depth: LocalDepth },
-    Br(Target),
-    BrIfEqz(Target),
-    BrIfNez(Target),
+    Br(<T as InstructionTypes>::Target),
+    BrIfEqz(<T as InstructionTypes>::Target),
+    BrIfNez(<T as InstructionTypes>::Target),
     ReturnIfNez(DropKeep),
     BrTable { len_targets: usize },
     Unreachable,
@@ -207,11 +217,14 @@ pub enum Instruction {
     I64TruncSatF64U,
 }
 
-impl Instruction {
+impl<T> Instruction<T>
+where
+    T: InstructionTypes,
+{
     /// Creates a new `Const` instruction from the given value.
-    pub fn constant<T>(value: T) -> Self
+    pub fn constant<C>(value: C) -> Self
     where
-        T: Into<UntypedValue>,
+        C: Into<UntypedValue>,
     {
         Self::Const(value.into())
     }
diff --git a/crates/wasmi/src/engine/bytecode/tests.rs b/crates/wasmi/src/engine/bytecode/tests.rs
index f1bf0e5617..89911c4645 100644
--- a/crates/wasmi/src/engine/bytecode/tests.rs
+++ b/crates/wasmi/src/engine/bytecode/tests.rs
@@ -1,8 +1,9 @@
 use super::*;
+use crate::engine::executor::ExecInstruction;
 
 #[test]
 fn size_of_instruction() {
-    assert_eq!(core::mem::size_of::<Instruction>(), 16);
+    assert_eq!(core::mem::size_of::<ExecInstruction>(), 16);
     assert_eq!(core::mem::size_of::<DropKeep>(), 4);
     assert_eq!(core::mem::size_of::<Target>(), 8);
 }
diff --git a/crates/wasmi/src/engine/code_map.rs b/crates/wasmi/src/engine/code_map.rs
index 60e43fc9f3..bbe7675df0 100644
--- a/crates/wasmi/src/engine/code_map.rs
+++ b/crates/wasmi/src/engine/code_map.rs
@@ -1,6 +1,6 @@
 //! Datastructure to efficiently store function bodies and their instructions.
 
-use super::{super::Index, Instruction};
+use super::{super::Index, executor::ExecInstruction};
 use alloc::vec::Vec;
 
 /// A reference to a Wasm function body stored in the [`CodeMap`].
@@ -73,7 +73,7 @@ pub struct CodeMap {
     ///
     /// Also this improves efficiency of deallocating the [`CodeMap`]
     /// and generally improves data locality.
-    insts: Vec<Instruction>,
+    insts: Vec<ExecInstruction>,
 }
 
 impl CodeMap {
@@ -84,7 +84,7 @@ impl CodeMap {
     /// instructions.
     pub fn alloc<I>(&mut self, len_locals: usize, max_stack_height: usize, insts: I) -> FuncBody
     where
-        I: IntoIterator<Item = Instruction>,
+        I: IntoIterator<Item = ExecInstruction>,
     {
         let start = self.insts.len();
         self.insts.extend(insts);
@@ -116,7 +116,7 @@ impl CodeMap {
 /// The instructions of a resolved [`FuncBody`].
 #[derive(Debug, Copy, Clone)]
 pub struct Instructions<'a> {
-    insts: &'a [Instruction],
+    insts: &'a [ExecInstruction],
 }
 
 impl<'a> Instructions<'a> {
@@ -126,7 +126,7 @@ impl<'a> Instructions<'a> {
     ///
     /// If there is no instruction at the given index.
     #[cfg(test)]
-    pub fn get(&self, index: usize) -> Option<&Instruction> {
+    pub fn get(&self, index: usize) -> Option<&ExecInstruction> {
         self.insts.get(index)
     }
 
@@ -136,7 +136,7 @@ impl<'a> Instructions<'a> {
     ///
     /// Panics in debug mode if the `pc` is invalid for the [`Instructions`].
     #[inline(always)]
-    pub unsafe fn get_release_unchecked(&self, pc: usize) -> &'a Instruction {
+    pub unsafe fn get_release_unchecked(&self, pc: usize) -> &'a ExecInstruction {
         debug_assert!(
             self.insts.get(pc).is_some(),
             "unexpectedly missing instruction at index {pc}",
diff --git a/crates/wasmi/src/engine/executor.rs b/crates/wasmi/src/engine/executor.rs
index f11ae459fd..23134788fb 100644
--- a/crates/wasmi/src/engine/executor.rs
+++ b/crates/wasmi/src/engine/executor.rs
@@ -1,6 +1,14 @@
 use super::{
     super::{Memory, Table},
-    bytecode::{FuncIdx, GlobalIdx, Instruction, LocalDepth, Offset, SignatureIdx},
+    bytecode::{
+        FuncIdx,
+        GlobalIdx,
+        Instruction,
+        InstructionTypes,
+        LocalDepth,
+        Offset,
+        SignatureIdx,
+    },
     cache::InstanceCache,
     code_map::Instructions,
     stack::ValueStackRef,
@@ -20,6 +28,17 @@ use crate::{
 use core::cmp;
 use wasmi_core::{memory_units::Pages, ExtendInto, LittleEndianConvert, UntypedValue, WrapInto};
 
+/// Base implementer for executable [`InstructionTypes`].
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ExecInstructionTypes {}
+
+impl InstructionTypes for ExecInstructionTypes {
+    type Target = Target;
+}
+
+/// An executable compiled [`Instruction`].
+pub type ExecInstruction = Instruction<ExecInstructionTypes>;
+
 /// Executes the given function `frame`.
 ///
 /// # Note
@@ -275,9 +294,9 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         }
     }
 
-    /// Returns the [`Instruction`] at the current program counter.
+    /// Returns the [`ExecInstruction`] at the current program counter.
     #[inline(always)]
-    fn instr(&self) -> &'engine Instruction {
+    fn instr(&self) -> &'engine ExecInstruction {
         // # Safety
         //
         // Properly constructed `wasmi` bytecode can never produce invalid `pc`.
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 12a1d5e73b..f31f5b6dbc 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -1,9 +1,11 @@
 //! Abstractions to build up instructions forming Wasm function bodies.
 
-use crate::engine::{Engine, FuncBody, Instruction};
+use crate::engine::{executor::ExecInstruction, Engine, FuncBody, Instruction};
 use alloc::vec::Vec;
 use core::mem;
 
+use super::IrInstruction;
+
 /// A reference to an instruction of the partially
 /// constructed function body of the [`InstructionsBuilder`].
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -104,7 +106,7 @@ impl RelativeDepth {
 #[derive(Debug, Default)]
 pub struct InstructionsBuilder {
     /// The instructions of the partially constructed function body.
-    insts: Vec<Instruction>,
+    insts: Vec<IrInstruction>,
     /// All labels and their uses.
     labels: Vec<Label>,
 }
@@ -201,7 +203,7 @@ impl InstructionsBuilder {
     /// Pushes the internal instruction bytecode to the [`InstructionsBuilder`].
     ///
     /// Returns an [`InstructionIdx`] to refer to the pushed instruction.
-    pub fn push_inst(&mut self, inst: Instruction) -> Instr {
+    pub fn push_inst(&mut self, inst: IrInstruction) -> Instr {
         let idx = self.current_pc();
         self.insts.push(inst);
         idx
@@ -251,6 +253,198 @@ impl InstructionsBuilder {
         len_locals: usize,
         max_stack_height: usize,
     ) -> FuncBody {
-        engine.alloc_func_body(len_locals, max_stack_height, self.insts.drain(..))
+        engine.alloc_func_body(
+            len_locals,
+            max_stack_height,
+            self.insts
+                .drain(..)
+                .map(|instr| instr.compile(&self.labels)),
+        )
+    }
+}
+
+impl IrInstruction {
+    /// Compiles the [`IrInstruction`] to an [`ExecInstruction`].
+    fn compile(self, labels: &Vec<Label>) -> ExecInstruction {
+        match self {
+            Self::LocalGet { local_depth } => Instruction::LocalGet { local_depth },
+            Self::LocalSet { local_depth } => Instruction::LocalSet { local_depth },
+            Self::LocalTee { local_depth } => Instruction::LocalTee { local_depth },
+            Self::Br(target) => Instruction::Br(target),
+            Self::BrIfEqz(target) => Instruction::BrIfEqz(target),
+            Self::BrIfNez(target) => Instruction::BrIfNez(target),
+            Self::ReturnIfNez(drop_keep) => Instruction::ReturnIfNez(drop_keep),
+            Self::BrTable { len_targets } => Instruction::BrTable { len_targets },
+            Self::Unreachable => Instruction::Unreachable,
+            Self::Return(drop_keep) => Instruction::Return(drop_keep),
+            Self::Call(func_idx) => Instruction::Call(func_idx),
+            Self::CallIndirect(func_type_idx) => Instruction::CallIndirect(func_type_idx),
+            Self::Drop => Instruction::Drop,
+            Self::Select => Instruction::Select,
+            Self::GlobalGet(global_idx) => Instruction::GlobalGet(global_idx),
+            Self::GlobalSet(global_idx) => Instruction::GlobalSet(global_idx),
+            Self::I32Load(offset) => Instruction::I32Load(offset),
+            Self::I64Load(offset) => Instruction::I64Load(offset),
+            Self::F32Load(offset) => Instruction::F32Load(offset),
+            Self::F64Load(offset) => Instruction::F64Load(offset),
+            Self::I32Load8S(offset) => Instruction::I32Load8S(offset),
+            Self::I32Load8U(offset) => Instruction::I32Load8U(offset),
+            Self::I32Load16S(offset) => Instruction::I32Load16S(offset),
+            Self::I32Load16U(offset) => Instruction::I32Load16U(offset),
+            Self::I64Load8S(offset) => Instruction::I64Load8S(offset),
+            Self::I64Load8U(offset) => Instruction::I64Load8U(offset),
+            Self::I64Load16S(offset) => Instruction::I64Load16S(offset),
+            Self::I64Load16U(offset) => Instruction::I64Load16U(offset),
+            Self::I64Load32S(offset) => Instruction::I64Load32S(offset),
+            Self::I64Load32U(offset) => Instruction::I64Load32U(offset),
+            Self::I32Store(offset) => Instruction::I32Store(offset),
+            Self::I64Store(offset) => Instruction::I64Store(offset),
+            Self::F32Store(offset) => Instruction::F32Store(offset),
+            Self::F64Store(offset) => Instruction::F64Store(offset),
+            Self::I32Store8(offset) => Instruction::I32Store8(offset),
+            Self::I32Store16(offset) => Instruction::I32Store16(offset),
+            Self::I64Store8(offset) => Instruction::I64Store8(offset),
+            Self::I64Store16(offset) => Instruction::I64Store16(offset),
+            Self::I64Store32(offset) => Instruction::I64Store32(offset),
+            Self::MemorySize => Instruction::MemorySize,
+            Self::MemoryGrow => Instruction::MemoryGrow,
+            Self::Const(value) => Instruction::Const(value),
+            Self::I32Eqz => Instruction::I32Eqz,
+            Self::I32Eq => Instruction::I32Eq,
+            Self::I32Ne => Instruction::I32Ne,
+            Self::I32LtS => Instruction::I32LtS,
+            Self::I32LtU => Instruction::I32LtU,
+            Self::I32GtS => Instruction::I32GtS,
+            Self::I32GtU => Instruction::I32GtU,
+            Self::I32LeS => Instruction::I32LeS,
+            Self::I32LeU => Instruction::I32LeU,
+            Self::I32GeS => Instruction::I32GeS,
+            Self::I32GeU => Instruction::I32GeU,
+            Self::I64Eqz => Instruction::I64Eqz,
+            Self::I64Eq => Instruction::I64Eq,
+            Self::I64Ne => Instruction::I64Ne,
+            Self::I64LtS => Instruction::I64LtS,
+            Self::I64LtU => Instruction::I64LtU,
+            Self::I64GtS => Instruction::I64GtS,
+            Self::I64GtU => Instruction::I64GtU,
+            Self::I64LeS => Instruction::I64LeS,
+            Self::I64LeU => Instruction::I64LeU,
+            Self::I64GeS => Instruction::I64GeS,
+            Self::I64GeU => Instruction::I64GeU,
+            Self::F32Eq => Instruction::F32Eq,
+            Self::F32Ne => Instruction::F32Ne,
+            Self::F32Lt => Instruction::F32Lt,
+            Self::F32Gt => Instruction::F32Gt,
+            Self::F32Le => Instruction::F32Le,
+            Self::F32Ge => Instruction::F32Ge,
+            Self::F64Eq => Instruction::F64Eq,
+            Self::F64Ne => Instruction::F64Ne,
+            Self::F64Lt => Instruction::F64Lt,
+            Self::F64Gt => Instruction::F64Gt,
+            Self::F64Le => Instruction::F64Le,
+            Self::F64Ge => Instruction::F64Ge,
+            Self::I32Clz => Instruction::I32Clz,
+            Self::I32Ctz => Instruction::I32Ctz,
+            Self::I32Popcnt => Instruction::I32Popcnt,
+            Self::I32Add => Instruction::I32Add,
+            Self::I32Sub => Instruction::I32Sub,
+            Self::I32Mul => Instruction::I32Mul,
+            Self::I32DivS => Instruction::I32DivS,
+            Self::I32DivU => Instruction::I32DivU,
+            Self::I32RemS => Instruction::I32RemS,
+            Self::I32RemU => Instruction::I32RemU,
+            Self::I32And => Instruction::I32And,
+            Self::I32Or => Instruction::I32Or,
+            Self::I32Xor => Instruction::I32Xor,
+            Self::I32Shl => Instruction::I32Shl,
+            Self::I32ShrS => Instruction::I32ShrS,
+            Self::I32ShrU => Instruction::I32ShrU,
+            Self::I32Rotl => Instruction::I32Rotl,
+            Self::I32Rotr => Instruction::I32Rotr,
+            Self::I64Clz => Instruction::I64Clz,
+            Self::I64Ctz => Instruction::I64Ctz,
+            Self::I64Popcnt => Instruction::I64Popcnt,
+            Self::I64Add => Instruction::I64Add,
+            Self::I64Sub => Instruction::I64Sub,
+            Self::I64Mul => Instruction::I64Mul,
+            Self::I64DivS => Instruction::I64DivS,
+            Self::I64DivU => Instruction::I64DivU,
+            Self::I64RemS => Instruction::I64RemS,
+            Self::I64RemU => Instruction::I64RemU,
+            Self::I64And => Instruction::I64And,
+            Self::I64Or => Instruction::I64Or,
+            Self::I64Xor => Instruction::I64Xor,
+            Self::I64Shl => Instruction::I64Shl,
+            Self::I64ShrS => Instruction::I64ShrS,
+            Self::I64ShrU => Instruction::I64ShrU,
+            Self::I64Rotl => Instruction::I64Rotl,
+            Self::I64Rotr => Instruction::I64Rotr,
+            Self::F32Abs => Instruction::F32Abs,
+            Self::F32Neg => Instruction::F32Neg,
+            Self::F32Ceil => Instruction::F32Ceil,
+            Self::F32Floor => Instruction::F32Floor,
+            Self::F32Trunc => Instruction::F32Trunc,
+            Self::F32Nearest => Instruction::F32Nearest,
+            Self::F32Sqrt => Instruction::F32Sqrt,
+            Self::F32Add => Instruction::F32Add,
+            Self::F32Sub => Instruction::F32Sub,
+            Self::F32Mul => Instruction::F32Mul,
+            Self::F32Div => Instruction::F32Div,
+            Self::F32Min => Instruction::F32Min,
+            Self::F32Max => Instruction::F32Max,
+            Self::F32Copysign => Instruction::F32Copysign,
+            Self::F64Abs => Instruction::F64Abs,
+            Self::F64Neg => Instruction::F64Neg,
+            Self::F64Ceil => Instruction::F64Ceil,
+            Self::F64Floor => Instruction::F64Floor,
+            Self::F64Trunc => Instruction::F64Trunc,
+            Self::F64Nearest => Instruction::F64Nearest,
+            Self::F64Sqrt => Instruction::F64Sqrt,
+            Self::F64Add => Instruction::F64Add,
+            Self::F64Sub => Instruction::F64Sub,
+            Self::F64Mul => Instruction::F64Mul,
+            Self::F64Div => Instruction::F64Div,
+            Self::F64Min => Instruction::F64Min,
+            Self::F64Max => Instruction::F64Max,
+            Self::F64Copysign => Instruction::F64Copysign,
+            Self::I32WrapI64 => Instruction::I32WrapI64,
+            Self::I32TruncSF32 => Instruction::I32TruncSF32,
+            Self::I32TruncUF32 => Instruction::I32TruncUF32,
+            Self::I32TruncSF64 => Instruction::I32TruncSF64,
+            Self::I32TruncUF64 => Instruction::I32TruncUF64,
+            Self::I64ExtendSI32 => Instruction::I64ExtendSI32,
+            Self::I64ExtendUI32 => Instruction::I64ExtendUI32,
+            Self::I64TruncSF32 => Instruction::I64TruncSF32,
+            Self::I64TruncUF32 => Instruction::I64TruncUF32,
+            Self::I64TruncSF64 => Instruction::I64TruncSF64,
+            Self::I64TruncUF64 => Instruction::I64TruncUF64,
+            Self::F32ConvertSI32 => Instruction::F32ConvertSI32,
+            Self::F32ConvertUI32 => Instruction::F32ConvertUI32,
+            Self::F32ConvertSI64 => Instruction::F32ConvertSI64,
+            Self::F32ConvertUI64 => Instruction::F32ConvertUI64,
+            Self::F32DemoteF64 => Instruction::F32DemoteF64,
+            Self::F64ConvertSI32 => Instruction::F64ConvertSI32,
+            Self::F64ConvertUI32 => Instruction::F64ConvertUI32,
+            Self::F64ConvertSI64 => Instruction::F64ConvertSI64,
+            Self::F64ConvertUI64 => Instruction::F64ConvertUI64,
+            Self::F64PromoteF32 => Instruction::F64PromoteF32,
+            Self::I32ReinterpretF32 => Instruction::I32ReinterpretF32,
+            Self::I64ReinterpretF64 => Instruction::I64ReinterpretF64,
+            Self::F32ReinterpretI32 => Instruction::F32ReinterpretI32,
+            Self::F64ReinterpretI64 => Instruction::F64ReinterpretI64,
+            Self::I32Extend8S => Instruction::I32Extend8S,
+            Self::I32Extend16S => Instruction::I32Extend16S,
+            Self::I64Extend8S => Instruction::I64Extend8S,
+            Self::I64Extend16S => Instruction::I64Extend16S,
+            Self::I64Extend32S => Instruction::I64Extend32S,
+            Self::I32TruncSatF32S => Instruction::I32TruncSatF32S,
+            Self::I32TruncSatF32U => Instruction::I32TruncSatF32U,
+            Self::I32TruncSatF64S => Instruction::I32TruncSatF64S,
+            Self::I32TruncSatF64U => Instruction::I32TruncSatF64U,
+            Self::I64TruncSatF32S => Instruction::I64TruncSatF32S,
+            Self::I64TruncSatF32U => Instruction::I64TruncSatF32U,
+            Self::I64TruncSatF64S => Instruction::I64TruncSatF64S,
+            Self::I64TruncSatF64U => Instruction::I64TruncSatF64U,
+        }
     }
 }
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index f02fd2e3bf..5f95c264f1 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -23,7 +23,7 @@ pub use self::{
     error::TranslationError,
     inst_builder::{Instr, InstructionsBuilder, LabelRef, RelativeDepth, Reloc},
 };
-use super::{DropKeep, FuncBody, Instruction, Target};
+use super::{bytecode::InstructionTypes, DropKeep, FuncBody, Instruction, Target};
 use crate::{
     engine::bytecode::Offset,
     module::{
@@ -47,6 +47,17 @@ use wasmi_core::{Value, ValueType, F32, F64};
 /// The used function validator type.
 type FuncValidator = wasmparser::FuncValidator<wasmparser::ValidatorResources>;
 
+/// Base implementer for intermeidate representation (IR) [`InstructionTypes`].
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum IrInstructionTypes {}
+
+impl InstructionTypes for IrInstructionTypes {
+    type Target = Target;
+}
+
+/// An intermediate representation [`Instruction`].
+pub type IrInstruction = Instruction<IrInstructionTypes>;
+
 /// The interface to translate a `wasmi` bytecode function using Wasm bytecode.
 pub struct FuncBuilder<'parser> {
     /// The [`Engine`] for which the function is translated.
@@ -87,7 +98,7 @@ pub struct FunctionBuilderAllocations {
     /// Stores and resolves local variable types.
     locals: LocalsRegistry,
     /// Buffer for translating `br_table`.
-    br_table_branches: Vec<Instruction>,
+    br_table_branches: Vec<IrInstruction>,
 }
 
 impl FunctionBuilderAllocations {
@@ -639,7 +650,7 @@ impl<'parser> FuncBuilder<'parser> {
                 builder: &mut FuncBuilder,
                 n: usize,
                 depth: RelativeDepth,
-            ) -> Result<Instruction, TranslationError> {
+            ) -> Result<IrInstruction, TranslationError> {
                 match builder.acquire_target(depth.into_u32())? {
                     AcquiredTarget::Branch(label_idx, drop_keep) => {
                         let dst_pc = builder.try_resolve_label(label_idx, |pc| Reloc::BrTable {
@@ -896,7 +907,7 @@ impl<'parser> FuncBuilder<'parser> {
         &mut self,
         memarg: wasmparser::MemArg,
         loaded_type: ValueType,
-        make_inst: fn(Offset) -> Instruction,
+        make_inst: fn(Offset) -> IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (memory_idx, offset) = Self::decompose_memarg(memarg);
@@ -1041,7 +1052,7 @@ impl<'parser> FuncBuilder<'parser> {
         &mut self,
         memarg: wasmparser::MemArg,
         stored_value: ValueType,
-        make_inst: fn(Offset) -> Instruction,
+        make_inst: fn(Offset) -> IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (memory_idx, offset) = Self::decompose_memarg(memarg);
@@ -1225,7 +1236,7 @@ impl<'parser> FuncBuilder<'parser> {
     fn translate_unary_cmp(
         &mut self,
         input_type: ValueType,
-        inst: Instruction,
+        inst: IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let condition = builder.alloc.value_stack.pop1();
@@ -1256,7 +1267,7 @@ impl<'parser> FuncBuilder<'parser> {
     fn translate_binary_cmp(
         &mut self,
         input_type: ValueType,
-        inst: Instruction,
+        inst: IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (v0, v1) = builder.alloc.value_stack.pop2();
@@ -1452,7 +1463,7 @@ impl<'parser> FuncBuilder<'parser> {
     pub fn translate_unary_operation(
         &mut self,
         value_type: ValueType,
-        inst: Instruction,
+        inst: IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let actual_type = builder.alloc.value_stack.top();
@@ -1501,7 +1512,7 @@ impl<'parser> FuncBuilder<'parser> {
     pub fn translate_binary_operation(
         &mut self,
         value_type: ValueType,
-        inst: Instruction,
+        inst: IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (v0, v1) = builder.alloc.value_stack.pop2();
@@ -1838,7 +1849,7 @@ impl<'parser> FuncBuilder<'parser> {
         &mut self,
         input_type: ValueType,
         output_type: ValueType,
-        inst: Instruction,
+        inst: IrInstruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let input = builder.alloc.value_stack.pop1();
diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
index 1023bfa515..7715b6f035 100644
--- a/crates/wasmi/src/engine/mod.rs
+++ b/crates/wasmi/src/engine/mod.rs
@@ -16,7 +16,7 @@ use self::{
     bytecode::Instruction,
     cache::InstanceCache,
     code_map::CodeMap,
-    executor::execute_frame,
+    executor::{execute_frame, ExecInstruction},
     func_types::FuncTypeRegistry,
     stack::{FuncFrame, Stack, ValueStack},
 };
@@ -154,7 +154,7 @@ impl Engine {
         insts: I,
     ) -> FuncBody
     where
-        I: IntoIterator<Item = Instruction>,
+        I: IntoIterator<Item = ExecInstruction>,
         I::IntoIter: ExactSizeIterator,
     {
         self.inner
@@ -174,7 +174,11 @@ impl Engine {
     ///
     /// If the [`FuncBody`] is invalid for the [`Engine`].
     #[cfg(test)]
-    pub(crate) fn resolve_inst(&self, func_body: FuncBody, index: usize) -> Option<Instruction> {
+    pub(crate) fn resolve_inst(
+        &self,
+        func_body: FuncBody,
+        index: usize,
+    ) -> Option<ExecInstruction> {
         let this = self.inner.lock();
         let iref = this.code_map.header(func_body).iref();
         this.code_map.insts(iref).get(index).copied()
@@ -257,7 +261,7 @@ impl EngineInner {
         insts: I,
     ) -> FuncBody
     where
-        I: IntoIterator<Item = Instruction>,
+        I: IntoIterator<Item = ExecInstruction>,
         I::IntoIter: ExactSizeIterator,
     {
         self.code_map.alloc(len_locals, max_stack_height, insts)
diff --git a/crates/wasmi/src/module/tests.rs b/crates/wasmi/src/module/tests.rs
index add1e00601..f1b5ed80be 100644
--- a/crates/wasmi/src/module/tests.rs
+++ b/crates/wasmi/src/module/tests.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::{
-    engine::{bytecode::Instruction, DropKeep, Instr, Target},
+    engine::{bytecode::Instruction, executor::ExecInstruction, DropKeep, Instr, Target},
     Engine,
 };
 
@@ -31,7 +31,7 @@ fn assert_func_body<E>(
     func_body: FuncBody,
     expected_instructions: E,
 ) where
-    E: IntoIterator<Item = Instruction>,
+    E: IntoIterator<Item = ExecInstruction>,
     <E as IntoIterator>::IntoIter: ExactSizeIterator,
 {
     let expected_instructions = expected_instructions.into_iter();
@@ -75,7 +75,7 @@ fn assert_func_body<E>(
 fn assert_func_bodies<E, T>(wasm_bytes: impl AsRef<[u8]>, expected: E)
 where
     E: IntoIterator<Item = T>,
-    T: IntoIterator<Item = Instruction>,
+    T: IntoIterator<Item = ExecInstruction>,
     <T as IntoIterator>::IntoIter: ExactSizeIterator,
 {
     let wasm_bytes = wasm_bytes.as_ref();

From f1486fa71780637aa7dceb6559a36afceb435829 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 13:57:27 +0200
Subject: [PATCH 05/15] remove superflous newline

---
 crates/wasmi/src/engine/func_builder/inst_builder.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index f31f5b6dbc..54cae24150 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -3,7 +3,6 @@
 use crate::engine::{executor::ExecInstruction, Engine, FuncBody, Instruction};
 use alloc::vec::Vec;
 use core::mem;
-
 use super::IrInstruction;
 
 /// A reference to an instruction of the partially

From 27fcf8768cb1eea84e438a9548934146a445d85d Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 14:01:42 +0200
Subject: [PATCH 06/15] rename Target -> BranchParams

Also rename
- BranchParams::destination_pc -> target
- BranchParams::update_destination_pc -> update_target
---
 crates/wasmi/src/engine/bytecode/mod.rs       | 10 +++----
 crates/wasmi/src/engine/bytecode/tests.rs     |  2 +-
 crates/wasmi/src/engine/bytecode/utils.rs     | 28 ++++++++++---------
 crates/wasmi/src/engine/executor.rs           | 14 +++++-----
 .../src/engine/func_builder/inst_builder.rs   |  6 ++--
 crates/wasmi/src/engine/func_builder/mod.rs   | 14 +++++-----
 crates/wasmi/src/engine/mod.rs                |  2 +-
 crates/wasmi/src/module/tests.rs              |  4 +--
 8 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/crates/wasmi/src/engine/bytecode/mod.rs b/crates/wasmi/src/engine/bytecode/mod.rs
index a44209281f..12fac0c1c6 100644
--- a/crates/wasmi/src/engine/bytecode/mod.rs
+++ b/crates/wasmi/src/engine/bytecode/mod.rs
@@ -6,6 +6,7 @@ mod utils;
 mod tests;
 
 pub use self::utils::{
+    BranchParams,
     DropKeep,
     DropKeepError,
     FuncIdx,
@@ -13,7 +14,6 @@ pub use self::utils::{
     LocalDepth,
     Offset,
     SignatureIdx,
-    Target,
 };
 use core::fmt::Debug;
 use wasmi_core::UntypedValue;
@@ -21,7 +21,7 @@ use wasmi_core::UntypedValue;
 /// Internal types of an [`Instruction`] type.
 pub trait InstructionTypes {
     /// A branching target.
-    type Target: Debug + Copy + Clone + PartialEq + Eq;
+    type BranchParams: Debug + Copy + Clone + PartialEq + Eq;
 }
 
 /// The internal `wasmi` bytecode that is stored for Wasm functions.
@@ -40,9 +40,9 @@ where
     LocalGet { local_depth: LocalDepth },
     LocalSet { local_depth: LocalDepth },
     LocalTee { local_depth: LocalDepth },
-    Br(<T as InstructionTypes>::Target),
-    BrIfEqz(<T as InstructionTypes>::Target),
-    BrIfNez(<T as InstructionTypes>::Target),
+    Br(<T as InstructionTypes>::BranchParams),
+    BrIfEqz(<T as InstructionTypes>::BranchParams),
+    BrIfNez(<T as InstructionTypes>::BranchParams),
     ReturnIfNez(DropKeep),
     BrTable { len_targets: usize },
     Unreachable,
diff --git a/crates/wasmi/src/engine/bytecode/tests.rs b/crates/wasmi/src/engine/bytecode/tests.rs
index 89911c4645..5841e61dd6 100644
--- a/crates/wasmi/src/engine/bytecode/tests.rs
+++ b/crates/wasmi/src/engine/bytecode/tests.rs
@@ -5,5 +5,5 @@ use crate::engine::executor::ExecInstruction;
 fn size_of_instruction() {
     assert_eq!(core::mem::size_of::<ExecInstruction>(), 16);
     assert_eq!(core::mem::size_of::<DropKeep>(), 4);
-    assert_eq!(core::mem::size_of::<Target>(), 8);
+    assert_eq!(core::mem::size_of::<BranchParams>(), 8);
 }
diff --git a/crates/wasmi/src/engine/bytecode/utils.rs b/crates/wasmi/src/engine/bytecode/utils.rs
index cbacc16c2e..d5a223f816 100644
--- a/crates/wasmi/src/engine/bytecode/utils.rs
+++ b/crates/wasmi/src/engine/bytecode/utils.rs
@@ -70,22 +70,25 @@ impl DropKeep {
 /// need to be dropped and kept in order to maintain
 /// value stack integrity.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct Target {
-    /// The destination program counter.
-    dst_pc: Instr,
+pub struct BranchParams {
+    /// The target instruction to branch to.
+    target: Instr,
     /// How many values on the stack need to be dropped and kept.
     drop_keep: DropKeep,
 }
 
-impl Target {
+impl BranchParams {
     /// Creates a new `wasmi` branching target.
     pub fn new(dst_pc: Instr, drop_keep: DropKeep) -> Self {
-        Self { dst_pc, drop_keep }
+        Self {
+            target: dst_pc,
+            drop_keep,
+        }
     }
 
     /// Returns the destination program counter (as index).
-    pub fn destination_pc(self) -> Instr {
-        self.dst_pc
+    pub fn target(self) -> Instr {
+        self.target
     }
 
     /// Updates the destination program counter (as index).
@@ -93,15 +96,14 @@ impl Target {
     /// # Panics
     ///
     /// If the old destination program counter was not [`InstructionIdx::INVALID`].
-    pub fn update_destination_pc(&mut self, new_destination_pc: Instr) {
+    pub fn update_target(&mut self, new_destination_pc: Instr) {
         assert_eq!(
-            self.destination_pc(),
+            self.target(),
             Instr::INVALID,
-            "can only update the destination pc of a target with an invalid \
-            destination pc but found a valid one: {:?}",
-            self.destination_pc(),
+            "tried to update the target of a branch that already has a valid target: {:?}",
+            self.target(),
         );
-        self.dst_pc = new_destination_pc;
+        self.target = new_destination_pc;
     }
 
     /// Returns the amount of stack values to drop and keep upon taking the branch.
diff --git a/crates/wasmi/src/engine/executor.rs b/crates/wasmi/src/engine/executor.rs
index 23134788fb..4c16c887a0 100644
--- a/crates/wasmi/src/engine/executor.rs
+++ b/crates/wasmi/src/engine/executor.rs
@@ -13,10 +13,10 @@ use super::{
     code_map::Instructions,
     stack::ValueStackRef,
     AsContextMut,
+    BranchParams,
     CallOutcome,
     DropKeep,
     FuncFrame,
-    Target,
     ValueStack,
 };
 use crate::{
@@ -33,7 +33,7 @@ use wasmi_core::{memory_units::Pages, ExtendInto, LittleEndianConvert, UntypedVa
 pub enum ExecInstructionTypes {}
 
 impl InstructionTypes for ExecInstructionTypes {
-    type Target = Target;
+    type BranchParams = BranchParams;
 }
 
 /// An executable compiled [`Instruction`].
@@ -506,9 +506,9 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         self.pc += 1;
     }
 
-    fn branch_to(&mut self, target: Target) {
+    fn branch_to(&mut self, target: BranchParams) {
         self.value_stack.drop_keep(target.drop_keep());
-        self.pc = target.destination_pc().into_usize();
+        self.pc = target.target().into_usize();
     }
 
     fn sync_stack_ptr(&mut self) {
@@ -539,11 +539,11 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         Err(TrapCode::Unreachable).map_err(Into::into)
     }
 
-    fn visit_br(&mut self, target: Target) {
+    fn visit_br(&mut self, target: BranchParams) {
         self.branch_to(target)
     }
 
-    fn visit_br_if_eqz(&mut self, target: Target) {
+    fn visit_br_if_eqz(&mut self, target: BranchParams) {
         let condition = self.value_stack.pop_as();
         if condition {
             self.next_instr()
@@ -552,7 +552,7 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         }
     }
 
-    fn visit_br_if_nez(&mut self, target: Target) {
+    fn visit_br_if_nez(&mut self, target: BranchParams) {
         let condition = self.value_stack.pop_as();
         if condition {
             self.branch_to(target)
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 54cae24150..e856df3ae8 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -1,9 +1,9 @@
 //! Abstractions to build up instructions forming Wasm function bodies.
 
+use super::IrInstruction;
 use crate::engine::{executor::ExecInstruction, Engine, FuncBody, Instruction};
 use alloc::vec::Vec;
 use core::mem;
-use super::IrInstruction;
 
 /// A reference to an instruction of the partially
 /// constructed function body of the [`InstructionsBuilder`].
@@ -215,7 +215,7 @@ impl InstructionsBuilder {
                 Instruction::Br(target)
                 | Instruction::BrIfEqz(target)
                 | Instruction::BrIfNez(target) => {
-                    target.update_destination_pc(dst_pc);
+                    target.update_target(dst_pc);
                 }
                 _ => panic!(
                     "branch relocation points to a non-branch instruction: {:?}",
@@ -227,7 +227,7 @@ impl InstructionsBuilder {
                 target_idx,
             } => match &mut self.insts[inst_idx.into_usize() + target_idx + 1] {
                 Instruction::Br(target) => {
-                    target.update_destination_pc(dst_pc);
+                    target.update_target(dst_pc);
                 }
                 _ => panic!(
                     "`br_table` relocation points to a non-`br_table` instruction: {:?}",
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index 5f95c264f1..07ddfbc863 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -23,7 +23,7 @@ pub use self::{
     error::TranslationError,
     inst_builder::{Instr, InstructionsBuilder, LabelRef, RelativeDepth, Reloc},
 };
-use super::{bytecode::InstructionTypes, DropKeep, FuncBody, Instruction, Target};
+use super::{bytecode::InstructionTypes, BranchParams, DropKeep, FuncBody, Instruction};
 use crate::{
     engine::bytecode::Offset,
     module::{
@@ -52,7 +52,7 @@ type FuncValidator = wasmparser::FuncValidator<wasmparser::ValidatorResources>;
 pub enum IrInstructionTypes {}
 
 impl InstructionTypes for IrInstructionTypes {
-    type Target = Target;
+    type BranchParams = BranchParams;
 }
 
 /// An intermediate representation [`Instruction`].
@@ -491,7 +491,7 @@ impl<'parser> FuncBuilder<'parser> {
                 stack_height,
             ));
             let dst_pc = self.try_resolve_label(else_label, |pc| Reloc::Br { inst_idx: pc });
-            let branch_target = Target::new(dst_pc, DropKeep::none());
+            let branch_target = BranchParams::new(dst_pc, DropKeep::none());
             self.alloc
                 .inst_builder
                 .push_inst(Instruction::BrIfEqz(branch_target));
@@ -535,7 +535,7 @@ impl<'parser> FuncBuilder<'parser> {
         if reachable {
             let dst_pc =
                 self.try_resolve_label(if_frame.end_label(), |pc| Reloc::Br { inst_idx: pc });
-            let target = Target::new(dst_pc, DropKeep::none());
+            let target = BranchParams::new(dst_pc, DropKeep::none());
             self.alloc.inst_builder.push_inst(Instruction::Br(target));
         }
         // Now resolve labels for the instructions of the `else` block
@@ -603,7 +603,7 @@ impl<'parser> FuncBuilder<'parser> {
                     builder
                         .alloc
                         .inst_builder
-                        .push_inst(Instruction::Br(Target::new(dst_pc, drop_keep)));
+                        .push_inst(Instruction::Br(BranchParams::new(dst_pc, drop_keep)));
                 }
                 AcquiredTarget::Return(_) => {
                     // In this case the `br` can be directly translated as `return`.
@@ -627,7 +627,7 @@ impl<'parser> FuncBuilder<'parser> {
                     builder
                         .alloc
                         .inst_builder
-                        .push_inst(Instruction::BrIfNez(Target::new(dst_pc, drop_keep)));
+                        .push_inst(Instruction::BrIfNez(BranchParams::new(dst_pc, drop_keep)));
                 }
                 AcquiredTarget::Return(drop_keep) => {
                     builder
@@ -657,7 +657,7 @@ impl<'parser> FuncBuilder<'parser> {
                             inst_idx: pc,
                             target_idx: n,
                         });
-                        Ok(Instruction::Br(Target::new(dst_pc, drop_keep)))
+                        Ok(Instruction::Br(BranchParams::new(dst_pc, drop_keep)))
                     }
                     AcquiredTarget::Return(drop_keep) => Ok(Instruction::Return(drop_keep)),
                 }
diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
index 7715b6f035..1f264ed4b8 100644
--- a/crates/wasmi/src/engine/mod.rs
+++ b/crates/wasmi/src/engine/mod.rs
@@ -21,7 +21,7 @@ use self::{
     stack::{FuncFrame, Stack, ValueStack},
 };
 pub use self::{
-    bytecode::{DropKeep, Target},
+    bytecode::{BranchParams, DropKeep},
     code_map::FuncBody,
     config::Config,
     func_builder::{
diff --git a/crates/wasmi/src/module/tests.rs b/crates/wasmi/src/module/tests.rs
index f1b5ed80be..744f30b19f 100644
--- a/crates/wasmi/src/module/tests.rs
+++ b/crates/wasmi/src/module/tests.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::{
-    engine::{bytecode::Instruction, executor::ExecInstruction, DropKeep, Instr, Target},
+    engine::{bytecode::Instruction, executor::ExecInstruction, BranchParams, DropKeep, Instr},
     Engine,
 };
 
@@ -294,7 +294,7 @@ fn drop_locals() {
 
 macro_rules! target {
     ( $inst_idx:expr, drop: $drop:expr, keep: $keep:expr ) => {
-        Target::new(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
+        BranchParams::new(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
     };
 }
 

From 0146fdaaffcf6edeb3d13335e6822ee53937d1af Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 16:02:43 +0200
Subject: [PATCH 07/15] introduce LabelRegistry

---
 crates/wasmi/src/engine/bytecode/mod.rs       |   1 -
 crates/wasmi/src/engine/bytecode/tests.rs     |   3 -
 crates/wasmi/src/engine/bytecode/utils.rs     |  49 -----
 crates/wasmi/src/engine/executor.rs           |  42 +++-
 .../src/engine/func_builder/control_frame.rs  |   3 +-
 .../src/engine/func_builder/inst_builder.rs   | 191 ++++++------------
 .../wasmi/src/engine/func_builder/labels.rs   | 110 ++++++++++
 crates/wasmi/src/engine/func_builder/mod.rs   |  86 ++++----
 crates/wasmi/src/engine/mod.rs                |  20 +-
 crates/wasmi/src/module/tests.rs              |   9 +-
 10 files changed, 275 insertions(+), 239 deletions(-)
 create mode 100644 crates/wasmi/src/engine/func_builder/labels.rs

diff --git a/crates/wasmi/src/engine/bytecode/mod.rs b/crates/wasmi/src/engine/bytecode/mod.rs
index 12fac0c1c6..cdeeae2c07 100644
--- a/crates/wasmi/src/engine/bytecode/mod.rs
+++ b/crates/wasmi/src/engine/bytecode/mod.rs
@@ -6,7 +6,6 @@ mod utils;
 mod tests;
 
 pub use self::utils::{
-    BranchParams,
     DropKeep,
     DropKeepError,
     FuncIdx,
diff --git a/crates/wasmi/src/engine/bytecode/tests.rs b/crates/wasmi/src/engine/bytecode/tests.rs
index 5841e61dd6..e018cd042b 100644
--- a/crates/wasmi/src/engine/bytecode/tests.rs
+++ b/crates/wasmi/src/engine/bytecode/tests.rs
@@ -1,9 +1,6 @@
 use super::*;
-use crate::engine::executor::ExecInstruction;
 
 #[test]
 fn size_of_instruction() {
-    assert_eq!(core::mem::size_of::<ExecInstruction>(), 16);
     assert_eq!(core::mem::size_of::<DropKeep>(), 4);
-    assert_eq!(core::mem::size_of::<BranchParams>(), 8);
 }
diff --git a/crates/wasmi/src/engine/bytecode/utils.rs b/crates/wasmi/src/engine/bytecode/utils.rs
index d5a223f816..077db25883 100644
--- a/crates/wasmi/src/engine/bytecode/utils.rs
+++ b/crates/wasmi/src/engine/bytecode/utils.rs
@@ -1,4 +1,3 @@
-use super::super::super::engine::Instr;
 use core::fmt::Display;
 
 /// Defines how many stack values are going to be dropped and kept after branching.
@@ -64,54 +63,6 @@ impl DropKeep {
     }
 }
 
-/// A branching target.
-///
-/// This also specifies how many values on the stack
-/// need to be dropped and kept in order to maintain
-/// value stack integrity.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct BranchParams {
-    /// The target instruction to branch to.
-    target: Instr,
-    /// How many values on the stack need to be dropped and kept.
-    drop_keep: DropKeep,
-}
-
-impl BranchParams {
-    /// Creates a new `wasmi` branching target.
-    pub fn new(dst_pc: Instr, drop_keep: DropKeep) -> Self {
-        Self {
-            target: dst_pc,
-            drop_keep,
-        }
-    }
-
-    /// Returns the destination program counter (as index).
-    pub fn target(self) -> Instr {
-        self.target
-    }
-
-    /// Updates the destination program counter (as index).
-    ///
-    /// # Panics
-    ///
-    /// If the old destination program counter was not [`InstructionIdx::INVALID`].
-    pub fn update_target(&mut self, new_destination_pc: Instr) {
-        assert_eq!(
-            self.target(),
-            Instr::INVALID,
-            "tried to update the target of a branch that already has a valid target: {:?}",
-            self.target(),
-        );
-        self.target = new_destination_pc;
-    }
-
-    /// Returns the amount of stack values to drop and keep upon taking the branch.
-    pub fn drop_keep(self) -> DropKeep {
-        self.drop_keep
-    }
-}
-
 /// A function index.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
diff --git a/crates/wasmi/src/engine/executor.rs b/crates/wasmi/src/engine/executor.rs
index 4c16c887a0..4145d8bff3 100644
--- a/crates/wasmi/src/engine/executor.rs
+++ b/crates/wasmi/src/engine/executor.rs
@@ -13,10 +13,10 @@ use super::{
     code_map::Instructions,
     stack::ValueStackRef,
     AsContextMut,
-    BranchParams,
     CallOutcome,
     DropKeep,
     FuncFrame,
+    Instr,
     ValueStack,
 };
 use crate::{
@@ -33,12 +33,42 @@ use wasmi_core::{memory_units::Pages, ExtendInto, LittleEndianConvert, UntypedVa
 pub enum ExecInstructionTypes {}
 
 impl InstructionTypes for ExecInstructionTypes {
-    type BranchParams = BranchParams;
+    type BranchParams = ExecBranchParams;
 }
 
 /// An executable compiled [`Instruction`].
 pub type ExecInstruction = Instruction<ExecInstructionTypes>;
 
+/// A branching target.
+///
+/// This also specifies how many values on the stack
+/// need to be dropped and kept in order to maintain
+/// value stack integrity.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct ExecBranchParams {
+    /// The target instruction to branch to.
+    target: Instr,
+    /// How many values on the stack need to be dropped and kept.
+    drop_keep: DropKeep,
+}
+
+impl ExecBranchParams {
+    /// Creates new branching parameters.
+    pub fn new(target: Instr, drop_keep: DropKeep) -> Self {
+        Self { target, drop_keep }
+    }
+
+    /// Returns the branching target.
+    pub fn target(self) -> Instr {
+        self.target
+    }
+
+    /// Returns the amount of stack values to drop and keep upon taking the branch.
+    pub fn drop_keep(self) -> DropKeep {
+        self.drop_keep
+    }
+}
+
 /// Executes the given function `frame`.
 ///
 /// # Note
@@ -506,7 +536,7 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         self.pc += 1;
     }
 
-    fn branch_to(&mut self, target: BranchParams) {
+    fn branch_to(&mut self, target: ExecBranchParams) {
         self.value_stack.drop_keep(target.drop_keep());
         self.pc = target.target().into_usize();
     }
@@ -539,11 +569,11 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         Err(TrapCode::Unreachable).map_err(Into::into)
     }
 
-    fn visit_br(&mut self, target: BranchParams) {
+    fn visit_br(&mut self, target: ExecBranchParams) {
         self.branch_to(target)
     }
 
-    fn visit_br_if_eqz(&mut self, target: BranchParams) {
+    fn visit_br_if_eqz(&mut self, target: ExecBranchParams) {
         let condition = self.value_stack.pop_as();
         if condition {
             self.next_instr()
@@ -552,7 +582,7 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         }
     }
 
-    fn visit_br_if_nez(&mut self, target: BranchParams) {
+    fn visit_br_if_nez(&mut self, target: ExecBranchParams) {
         let condition = self.value_stack.pop_as();
         if condition {
             self.branch_to(target)
diff --git a/crates/wasmi/src/engine/func_builder/control_frame.rs b/crates/wasmi/src/engine/func_builder/control_frame.rs
index 4917012464..38ba7cbe9b 100644
--- a/crates/wasmi/src/engine/func_builder/control_frame.rs
+++ b/crates/wasmi/src/engine/func_builder/control_frame.rs
@@ -1,4 +1,5 @@
-use crate::{engine::LabelRef, module::BlockType};
+use super::labels::LabelRef;
+use crate::module::BlockType;
 
 /// A Wasm `block` control flow frame.
 #[derive(Debug, Copy, Clone)]
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index e856df3ae8..d6512a758e 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -1,9 +1,17 @@
 //! Abstractions to build up instructions forming Wasm function bodies.
 
-use super::IrInstruction;
-use crate::engine::{executor::ExecInstruction, Engine, FuncBody, Instruction};
+use super::{
+    labels::{LabelRef, LabelRegistry},
+    IrBranchParams,
+    IrInstruction,
+};
+use crate::engine::{
+    executor::{ExecBranchParams, ExecInstruction},
+    Engine,
+    FuncBody,
+    Instruction,
+};
 use alloc::vec::Vec;
-use core::mem;
 
 /// A reference to an instruction of the partially
 /// constructed function body of the [`InstructionsBuilder`].
@@ -11,16 +19,6 @@ use core::mem;
 pub struct Instr(u32);
 
 impl Instr {
-    /// An invalid instruction index.
-    ///
-    /// # Note
-    ///
-    /// This can be used to represent temporarily invalid [`InstructionIdx`]
-    /// without major performance implications for the bytecode itself, e.g.
-    /// when representing invalid [`InstructionIdx`] by wrapping them in an
-    /// `Option`.
-    pub const INVALID: Self = Self(u32::MAX);
-
     /// Creates an [`InstructionIdx`] from the given `usize` value.
     ///
     /// # Note
@@ -46,40 +44,40 @@ impl Instr {
     }
 }
 
-/// A resolved or unresolved label.
-#[derive(Debug, PartialEq, Eq)]
-enum Label {
-    /// An unresolved label.
-    Unresolved {
-        /// The uses of the unresolved label.
-        uses: Vec<Reloc>,
-    },
-    /// A fully resolved label.
-    ///
-    /// # Note
-    ///
-    /// A fully resolved label no longer required knowledge about its uses.
-    Resolved(Instr),
-}
+// /// A resolved or unresolved label.
+// #[derive(Debug, PartialEq, Eq)]
+// enum Label {
+//     /// An unresolved label.
+//     Unresolved {
+//         /// The uses of the unresolved label.
+//         uses: Vec<Reloc>,
+//     },
+//     /// A fully resolved label.
+//     ///
+//     /// # Note
+//     ///
+//     /// A fully resolved label no longer required knowledge about its uses.
+//     Resolved(Instr),
+// }
 
-impl Default for Label {
-    fn default() -> Self {
-        Self::Unresolved { uses: Vec::new() }
-    }
-}
+// impl Default for Label {
+//     fn default() -> Self {
+//         Self::Unresolved { uses: Vec::new() }
+//     }
+// }
 
-/// A unique label identifier.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct LabelRef(pub(crate) usize);
+// /// A unique label identifier.
+// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+// pub struct LabelRef(pub(crate) usize);
 
-/// A relocation entry that specifies.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum Reloc {
-    /// Patch the target of the `br`, `br_eqz` or `br_nez` instruction.
-    Br { inst_idx: Instr },
-    /// Patch the specified target index inside of a Wasm `br_table` instruction.
-    BrTable { inst_idx: Instr, target_idx: usize },
-}
+// /// A relocation entry that specifies.
+// #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+// pub enum Reloc {
+//     /// Patch the target of the `br`, `br_eqz` or `br_nez` instruction.
+//     Br { inst_idx: Instr },
+//     /// Patch the specified target index inside of a Wasm `br_table` instruction.
+//     BrTable { inst_idx: Instr, target_idx: usize },
+// }
 
 /// The relative depth of a Wasm branching target.
 #[derive(Debug, Copy, Clone)]
@@ -107,14 +105,14 @@ pub struct InstructionsBuilder {
     /// The instructions of the partially constructed function body.
     insts: Vec<IrInstruction>,
     /// All labels and their uses.
-    labels: Vec<Label>,
+    labels: LabelRegistry,
 }
 
 impl InstructionsBuilder {
     /// Resets the [`InstructionsBuilder`] to allow for reuse.
     pub fn reset(&mut self) {
         self.insts.clear();
-        self.labels.clear();
+        self.labels.reset();
     }
 
     /// Returns the current instruction pointer as index.
@@ -124,17 +122,7 @@ impl InstructionsBuilder {
 
     /// Creates a new unresolved label and returns an index to it.
     pub fn new_label(&mut self) -> LabelRef {
-        let idx = LabelRef(self.labels.len());
-        self.labels.push(Label::default());
-        idx
-    }
-
-    /// Returns `true` if `label` has been resolved.
-    fn is_resolved(&self, label: LabelRef) -> bool {
-        if let Label::Resolved(_) = &self.labels[label.0] {
-            return true;
-        }
-        false
+        self.labels.new_label()
     }
 
     /// Resolve the label at the current instruction position.
@@ -147,11 +135,7 @@ impl InstructionsBuilder {
     /// the given label can be resolved properly.
     /// This usually takes place when encountering the Wasm `End` operand for example.
     pub fn pin_label_if_unpinned(&mut self, label: LabelRef) {
-        if self.is_resolved(label) {
-            // Nothing to do in this case.
-            return;
-        }
-        self.pin_label(label);
+        self.labels.try_pin_label(label, self.current_pc())
     }
 
     /// Resolve the label at the current instruction position.
@@ -166,37 +150,9 @@ impl InstructionsBuilder {
     ///
     /// If the label has already been resolved.
     pub fn pin_label(&mut self, label: LabelRef) {
-        let dst_pc = self.current_pc();
-        let old_label = mem::replace(&mut self.labels[label.0], Label::Resolved(dst_pc));
-        match old_label {
-            Label::Resolved(idx) => panic!(
-                "tried to resolve already resolved label {:?} -> {:?} to {:?}",
-                label, idx, dst_pc
-            ),
-            Label::Unresolved { uses } => {
-                // Patch all relocations that have been recorded as uses of the resolved label.
-                for reloc in uses {
-                    self.patch_relocation(reloc, dst_pc);
-                }
-            }
-        }
-    }
-
-    /// Tries to resolve the label into the [`InstructionIdx`].
-    ///
-    /// If resolution fails puts a placeholder into the respective label
-    /// and push the new user for later resolution to take place.
-    pub fn try_resolve_label<F>(&mut self, label: LabelRef, reloc_provider: F) -> Instr
-    where
-        F: FnOnce() -> Reloc,
-    {
-        match &mut self.labels[label.0] {
-            Label::Resolved(dst_pc) => *dst_pc,
-            Label::Unresolved { uses } => {
-                uses.push(reloc_provider());
-                Instr::INVALID
-            }
-        }
+        self.labels
+            .pin_label(label, self.current_pc())
+            .unwrap_or_else(|err| panic!("failed to pin label: {err}"));
     }
 
     /// Pushes the internal instruction bytecode to the [`InstructionsBuilder`].
@@ -208,35 +164,6 @@ impl InstructionsBuilder {
         idx
     }
 
-    /// Allows to patch the branch target of branch instructions.
-    pub fn patch_relocation(&mut self, reloc: Reloc, dst_pc: Instr) {
-        match reloc {
-            Reloc::Br { inst_idx } => match &mut self.insts[inst_idx.into_usize()] {
-                Instruction::Br(target)
-                | Instruction::BrIfEqz(target)
-                | Instruction::BrIfNez(target) => {
-                    target.update_target(dst_pc);
-                }
-                _ => panic!(
-                    "branch relocation points to a non-branch instruction: {:?}",
-                    reloc
-                ),
-            },
-            Reloc::BrTable {
-                inst_idx,
-                target_idx,
-            } => match &mut self.insts[inst_idx.into_usize() + target_idx + 1] {
-                Instruction::Br(target) => {
-                    target.update_target(dst_pc);
-                }
-                _ => panic!(
-                    "`br_table` relocation points to a non-`br_table` instruction: {:?}",
-                    reloc
-                ),
-            },
-        }
-    }
-
     /// Finishes construction of the function body instructions.
     ///
     /// # Note
@@ -262,16 +189,28 @@ impl InstructionsBuilder {
     }
 }
 
+impl IrBranchParams {
+    /// Compiles the [`IrBranchParams`] to an [`ExecBranchParams`].
+    fn compile(self, labels: &LabelRegistry) -> ExecBranchParams {
+        ExecBranchParams::new(
+            labels
+                .resolve_label(self.target())
+                .unwrap_or_else(|err| panic!("failed to resolve label: {err}")),
+            self.drop_keep(),
+        )
+    }
+}
+
 impl IrInstruction {
     /// Compiles the [`IrInstruction`] to an [`ExecInstruction`].
-    fn compile(self, labels: &Vec<Label>) -> ExecInstruction {
+    fn compile(self, labels: &LabelRegistry) -> ExecInstruction {
         match self {
             Self::LocalGet { local_depth } => Instruction::LocalGet { local_depth },
             Self::LocalSet { local_depth } => Instruction::LocalSet { local_depth },
             Self::LocalTee { local_depth } => Instruction::LocalTee { local_depth },
-            Self::Br(target) => Instruction::Br(target),
-            Self::BrIfEqz(target) => Instruction::BrIfEqz(target),
-            Self::BrIfNez(target) => Instruction::BrIfNez(target),
+            Self::Br(target) => Instruction::Br(target.compile(labels)),
+            Self::BrIfEqz(target) => Instruction::BrIfEqz(target.compile(labels)),
+            Self::BrIfNez(target) => Instruction::BrIfNez(target.compile(labels)),
             Self::ReturnIfNez(drop_keep) => Instruction::ReturnIfNez(drop_keep),
             Self::BrTable { len_targets } => Instruction::BrTable { len_targets },
             Self::Unreachable => Instruction::Unreachable,
diff --git a/crates/wasmi/src/engine/func_builder/labels.rs b/crates/wasmi/src/engine/func_builder/labels.rs
new file mode 100644
index 0000000000..3660dc6ffe
--- /dev/null
+++ b/crates/wasmi/src/engine/func_builder/labels.rs
@@ -0,0 +1,110 @@
+use super::Instr;
+use alloc::vec::Vec;
+use core::fmt::{self, Display};
+
+/// A label during the `wasmi` compilation process.
+#[derive(Debug, Copy, Clone)]
+pub enum Label {
+    /// The label has already been pinned to a particular [`Instr`].
+    Pinned(Instr),
+    /// The label is still unpinned.
+    Unpinned,
+}
+
+impl Label {
+    /// Returns `true` if the [`Label`] has already been pinned.
+    pub fn is_pinned(&self) -> bool {
+        matches!(self, Self::Pinned(_))
+    }
+}
+
+/// A reference to an [`Label`].
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct LabelRef(usize);
+
+/// The label registry.
+///
+/// Allows to allocate new labels pin them and resolve pinned ones.
+#[derive(Debug, Default)]
+pub struct LabelRegistry {
+    labels: Vec<Label>,
+}
+
+/// An error that may occur while operating on the [`LabelRegistry`].
+#[derive(Debug, Copy, Clone)]
+pub enum LabelError {
+    /// When trying to pin an already pinned [`Label`].
+    AlreadyPinned { label: LabelRef, pinned_to: Instr },
+    /// When trying to resolve an unpinned [`Label`].
+    Unpinned { label: LabelRef },
+}
+
+impl Display for LabelError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LabelError::AlreadyPinned { label, pinned_to } => {
+                write!(
+                    f,
+                    "trying to pin already pinned label {label:?} (pinned to {pinned_to:?})"
+                )
+            }
+            LabelError::Unpinned { label } => {
+                write!(f, "trying to resolve unpinned label: {label:?}")
+            }
+        }
+    }
+}
+
+impl LabelRegistry {
+    /// Resets the [`LabelRegistry`] for reuse.
+    pub fn reset(&mut self) {
+        self.labels.clear()
+    }
+
+    /// Allocates a new unpinned [`Label`].
+    pub fn new_label(&mut self) -> LabelRef {
+        let index = self.labels.len();
+        self.labels.push(Label::Unpinned);
+        LabelRef(index)
+    }
+
+    /// Pins the `label` to the given `instr`.
+    ///
+    /// # Errors
+    ///
+    /// If the `label` has already been pinned to some other [`Instr`].
+    pub fn pin_label(&mut self, label: LabelRef, instr: Instr) -> Result<(), LabelError> {
+        match &mut self.labels[label.0] {
+            Label::Pinned(pinned) => {
+                return Err(LabelError::AlreadyPinned {
+                    label,
+                    pinned_to: *pinned,
+                })
+            }
+            unpinned @ Label::Unpinned => {
+                *unpinned = Label::Pinned(instr);
+            }
+        }
+        Ok(())
+    }
+
+    /// Pins the `label` to the given `instr` if unpinned.
+    pub fn try_pin_label(&mut self, label: LabelRef, instr: Instr) {
+        let label = &mut self.labels[label.0];
+        if !label.is_pinned() {
+            *label = Label::Pinned(instr)
+        }
+    }
+
+    /// Resolves a `label` to its pinned [`Instr`].
+    ///
+    /// # Errors
+    ///
+    /// If the `label` is unpinned.
+    pub fn resolve_label(&self, label: LabelRef) -> Result<Instr, LabelError> {
+        match &self.labels[label.0] {
+            Label::Pinned(instr) => Ok(*instr),
+            Label::Unpinned => Err(LabelError::Unpinned { label }),
+        }
+    }
+}
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index 07ddfbc863..e65f57158f 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -2,6 +2,7 @@ mod control_frame;
 mod control_stack;
 mod error;
 mod inst_builder;
+mod labels;
 mod locals_registry;
 mod value_stack;
 mod visit;
@@ -16,14 +17,15 @@ use self::{
         UnreachableControlFrame,
     },
     control_stack::ControlFlowStack,
+    labels::LabelRef,
     locals_registry::LocalsRegistry,
     value_stack::ValueStack,
 };
 pub use self::{
     error::TranslationError,
-    inst_builder::{Instr, InstructionsBuilder, LabelRef, RelativeDepth, Reloc},
+    inst_builder::{Instr, InstructionsBuilder, RelativeDepth},
 };
-use super::{bytecode::InstructionTypes, BranchParams, DropKeep, FuncBody, Instruction};
+use super::{bytecode::InstructionTypes, DropKeep, FuncBody, Instruction};
 use crate::{
     engine::bytecode::Offset,
     module::{
@@ -52,12 +54,42 @@ type FuncValidator = wasmparser::FuncValidator<wasmparser::ValidatorResources>;
 pub enum IrInstructionTypes {}
 
 impl InstructionTypes for IrInstructionTypes {
-    type BranchParams = BranchParams;
+    type BranchParams = IrBranchParams;
 }
 
 /// An intermediate representation [`Instruction`].
 pub type IrInstruction = Instruction<IrInstructionTypes>;
 
+/// A branching target.
+///
+/// This also specifies how many values on the stack
+/// need to be dropped and kept in order to maintain
+/// value stack integrity.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct IrBranchParams {
+    /// The label that refers to the branching target.
+    target: LabelRef,
+    /// How many values on the stack need to be dropped and kept.
+    drop_keep: DropKeep,
+}
+
+impl IrBranchParams {
+    /// Creates new branching parameters.
+    pub fn new(target: LabelRef, drop_keep: DropKeep) -> Self {
+        Self { target, drop_keep }
+    }
+
+    /// Returns the branching target.
+    pub fn target(self) -> LabelRef {
+        self.target
+    }
+
+    /// Returns the amount of stack values to drop and keep upon taking the branch.
+    pub fn drop_keep(self) -> DropKeep {
+        self.drop_keep
+    }
+}
+
 /// The interface to translate a `wasmi` bytecode function using Wasm bytecode.
 pub struct FuncBuilder<'parser> {
     /// The [`Engine`] for which the function is translated.
@@ -191,19 +223,6 @@ impl<'parser> FuncBuilder<'parser> {
         params.len()
     }
 
-    /// Try to resolve the given label.
-    ///
-    /// In case the label cannot yet be resolved register the [`Reloc`] as its user.
-    fn try_resolve_label<F>(&mut self, label: LabelRef, reloc_provider: F) -> Instr
-    where
-        F: FnOnce(Instr) -> Reloc,
-    {
-        let pc = self.alloc.inst_builder.current_pc();
-        self.alloc
-            .inst_builder
-            .try_resolve_label(label, || reloc_provider(pc))
-    }
-
     /// Translates the given local variables for the translated function.
     pub fn translate_locals(
         &mut self,
@@ -490,8 +509,7 @@ impl<'parser> FuncBuilder<'parser> {
                 else_label,
                 stack_height,
             ));
-            let dst_pc = self.try_resolve_label(else_label, |pc| Reloc::Br { inst_idx: pc });
-            let branch_target = BranchParams::new(dst_pc, DropKeep::none());
+            let branch_target = IrBranchParams::new(else_label, DropKeep::none());
             self.alloc
                 .inst_builder
                 .push_inst(Instruction::BrIfEqz(branch_target));
@@ -533,9 +551,7 @@ impl<'parser> FuncBuilder<'parser> {
         // Create the jump from the end of the `then` block to the `if`
         // block's end label in case the end of `then` is reachable.
         if reachable {
-            let dst_pc =
-                self.try_resolve_label(if_frame.end_label(), |pc| Reloc::Br { inst_idx: pc });
-            let target = BranchParams::new(dst_pc, DropKeep::none());
+            let target = IrBranchParams::new(if_frame.end_label(), DropKeep::none());
             self.alloc.inst_builder.push_inst(Instruction::Br(target));
         }
         // Now resolve labels for the instructions of the `else` block
@@ -598,12 +614,10 @@ impl<'parser> FuncBuilder<'parser> {
         self.translate_if_reachable(|builder| {
             match builder.acquire_target(relative_depth)? {
                 AcquiredTarget::Branch(end_label, drop_keep) => {
-                    let dst_pc =
-                        builder.try_resolve_label(end_label, |pc| Reloc::Br { inst_idx: pc });
                     builder
                         .alloc
                         .inst_builder
-                        .push_inst(Instruction::Br(BranchParams::new(dst_pc, drop_keep)));
+                        .push_inst(Instruction::Br(IrBranchParams::new(end_label, drop_keep)));
                 }
                 AcquiredTarget::Return(_) => {
                     // In this case the `br` can be directly translated as `return`.
@@ -622,12 +636,9 @@ impl<'parser> FuncBuilder<'parser> {
             debug_assert_eq!(condition, ValueType::I32);
             match builder.acquire_target(relative_depth)? {
                 AcquiredTarget::Branch(end_label, drop_keep) => {
-                    let dst_pc =
-                        builder.try_resolve_label(end_label, |pc| Reloc::Br { inst_idx: pc });
-                    builder
-                        .alloc
-                        .inst_builder
-                        .push_inst(Instruction::BrIfNez(BranchParams::new(dst_pc, drop_keep)));
+                    builder.alloc.inst_builder.push_inst(Instruction::BrIfNez(
+                        IrBranchParams::new(end_label, drop_keep),
+                    ));
                 }
                 AcquiredTarget::Return(drop_keep) => {
                     builder
@@ -648,16 +659,11 @@ impl<'parser> FuncBuilder<'parser> {
         self.translate_if_reachable(|builder| {
             fn compute_inst(
                 builder: &mut FuncBuilder,
-                n: usize,
                 depth: RelativeDepth,
             ) -> Result<IrInstruction, TranslationError> {
                 match builder.acquire_target(depth.into_u32())? {
-                    AcquiredTarget::Branch(label_idx, drop_keep) => {
-                        let dst_pc = builder.try_resolve_label(label_idx, |pc| Reloc::BrTable {
-                            inst_idx: pc,
-                            target_idx: n,
-                        });
-                        Ok(Instruction::Br(BranchParams::new(dst_pc, drop_keep)))
+                    AcquiredTarget::Branch(label, drop_keep) => {
+                        Ok(Instruction::Br(IrBranchParams::new(label, drop_keep)))
                     }
                     AcquiredTarget::Return(drop_keep) => Ok(Instruction::Return(drop_keep)),
                 }
@@ -680,14 +686,14 @@ impl<'parser> FuncBuilder<'parser> {
             debug_assert_eq!(case, ValueType::I32);
 
             builder.alloc.br_table_branches.clear();
-            for (n, depth) in targets.into_iter().enumerate() {
-                let relative_depth = compute_inst(builder, n, depth)?;
+            for depth in targets.into_iter() {
+                let relative_depth = compute_inst(builder, depth)?;
                 builder.alloc.br_table_branches.push(relative_depth);
             }
 
             // We include the default target in `len_branches`.
             let len_branches = builder.alloc.br_table_branches.len();
-            let default_branch = compute_inst(builder, len_branches, default)?;
+            let default_branch = compute_inst(builder, default)?;
             builder.alloc.inst_builder.push_inst(Instruction::BrTable {
                 len_targets: len_branches + 1,
             });
diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
index 1f264ed4b8..75b60d4b79 100644
--- a/crates/wasmi/src/engine/mod.rs
+++ b/crates/wasmi/src/engine/mod.rs
@@ -12,30 +12,28 @@ pub mod stack;
 mod traits;
 
 pub(crate) use self::func_args::{FuncParams, FuncResults};
-use self::{
-    bytecode::Instruction,
-    cache::InstanceCache,
-    code_map::CodeMap,
-    executor::{execute_frame, ExecInstruction},
-    func_types::FuncTypeRegistry,
-    stack::{FuncFrame, Stack, ValueStack},
-};
 pub use self::{
-    bytecode::{BranchParams, DropKeep},
+    bytecode::DropKeep,
     code_map::FuncBody,
     config::Config,
     func_builder::{
         FuncBuilder,
         FunctionBuilderAllocations,
         Instr,
-        LabelRef,
         RelativeDepth,
-        Reloc,
         TranslationError,
     },
     stack::StackLimits,
     traits::{CallParams, CallResults},
 };
+use self::{
+    bytecode::Instruction,
+    cache::InstanceCache,
+    code_map::CodeMap,
+    executor::{execute_frame, ExecInstruction},
+    func_types::FuncTypeRegistry,
+    stack::{FuncFrame, Stack, ValueStack},
+};
 use super::{func::FuncEntityInternal, AsContextMut, Func};
 use crate::{
     arena::{GuardedEntity, Index},
diff --git a/crates/wasmi/src/module/tests.rs b/crates/wasmi/src/module/tests.rs
index 744f30b19f..d159d55d5d 100644
--- a/crates/wasmi/src/module/tests.rs
+++ b/crates/wasmi/src/module/tests.rs
@@ -1,6 +1,11 @@
 use super::*;
 use crate::{
-    engine::{bytecode::Instruction, executor::ExecInstruction, BranchParams, DropKeep, Instr},
+    engine::{
+        bytecode::Instruction,
+        executor::{ExecBranchParams, ExecInstruction},
+        DropKeep,
+        Instr,
+    },
     Engine,
 };
 
@@ -294,7 +299,7 @@ fn drop_locals() {
 
 macro_rules! target {
     ( $inst_idx:expr, drop: $drop:expr, keep: $keep:expr ) => {
-        BranchParams::new(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
+        ExecBranchParams::new(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
     };
 }
 

From 274069eff32a4630a29b8d80b63e1c2557674e87 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 16:03:21 +0200
Subject: [PATCH 08/15] remove commented out code

---
 .../src/engine/func_builder/inst_builder.rs   | 35 -------------------
 1 file changed, 35 deletions(-)

diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index d6512a758e..43ee07bd0e 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -44,41 +44,6 @@ impl Instr {
     }
 }
 
-// /// A resolved or unresolved label.
-// #[derive(Debug, PartialEq, Eq)]
-// enum Label {
-//     /// An unresolved label.
-//     Unresolved {
-//         /// The uses of the unresolved label.
-//         uses: Vec<Reloc>,
-//     },
-//     /// A fully resolved label.
-//     ///
-//     /// # Note
-//     ///
-//     /// A fully resolved label no longer required knowledge about its uses.
-//     Resolved(Instr),
-// }
-
-// impl Default for Label {
-//     fn default() -> Self {
-//         Self::Unresolved { uses: Vec::new() }
-//     }
-// }
-
-// /// A unique label identifier.
-// #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-// pub struct LabelRef(pub(crate) usize);
-
-// /// A relocation entry that specifies.
-// #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-// pub enum Reloc {
-//     /// Patch the target of the `br`, `br_eqz` or `br_nez` instruction.
-//     Br { inst_idx: Instr },
-//     /// Patch the specified target index inside of a Wasm `br_table` instruction.
-//     BrTable { inst_idx: Instr, target_idx: usize },
-// }
-
 /// The relative depth of a Wasm branching target.
 #[derive(Debug, Copy, Clone)]
 pub struct RelativeDepth(u32);

From 4b0fbce701172ed5f64598a356d4ae8e7ce36d3a Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Mon, 26 Sep 2022 16:23:00 +0200
Subject: [PATCH 09/15] cleanup LabelRegistry

---
 .../wasmi/src/engine/func_builder/labels.rs   | 56 ++++++++++++-------
 1 file changed, 35 insertions(+), 21 deletions(-)

diff --git a/crates/wasmi/src/engine/func_builder/labels.rs b/crates/wasmi/src/engine/func_builder/labels.rs
index 3660dc6ffe..4611c8238d 100644
--- a/crates/wasmi/src/engine/func_builder/labels.rs
+++ b/crates/wasmi/src/engine/func_builder/labels.rs
@@ -11,16 +11,17 @@ pub enum Label {
     Unpinned,
 }
 
-impl Label {
-    /// Returns `true` if the [`Label`] has already been pinned.
-    pub fn is_pinned(&self) -> bool {
-        matches!(self, Self::Pinned(_))
-    }
-}
-
 /// A reference to an [`Label`].
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct LabelRef(usize);
+pub struct LabelRef(u32);
+
+impl LabelRef {
+    /// Returns the `usize` value of the [`LabelRef`].
+    #[inline]
+    fn into_usize(self) -> usize {
+        self.0 as usize
+    }
+}
 
 /// The label registry.
 ///
@@ -63,36 +64,49 @@ impl LabelRegistry {
 
     /// Allocates a new unpinned [`Label`].
     pub fn new_label(&mut self) -> LabelRef {
-        let index = self.labels.len();
+        let index: u32 = self
+            .labels
+            .len()
+            .try_into()
+            .unwrap_or_else(|err| panic!("cannot have more than u32::MAX label refs: {err}"));
         self.labels.push(Label::Unpinned);
         LabelRef(index)
     }
 
+    /// Returns a shared reference to the underlying [`Label`].
+    #[inline]
+    fn get_label(&self, label: LabelRef) -> &Label {
+        &self.labels[label.into_usize()]
+    }
+
+    /// Returns an exclusive reference to the underlying [`Label`].
+    #[inline]
+    fn get_label_mut(&mut self, label: LabelRef) -> &mut Label {
+        &mut self.labels[label.into_usize()]
+    }
+
     /// Pins the `label` to the given `instr`.
     ///
     /// # Errors
     ///
     /// If the `label` has already been pinned to some other [`Instr`].
     pub fn pin_label(&mut self, label: LabelRef, instr: Instr) -> Result<(), LabelError> {
-        match &mut self.labels[label.0] {
-            Label::Pinned(pinned) => {
-                return Err(LabelError::AlreadyPinned {
-                    label,
-                    pinned_to: *pinned,
-                })
-            }
+        match self.get_label_mut(label) {
+            Label::Pinned(pinned) => Err(LabelError::AlreadyPinned {
+                label,
+                pinned_to: *pinned,
+            }),
             unpinned @ Label::Unpinned => {
                 *unpinned = Label::Pinned(instr);
+                Ok(())
             }
         }
-        Ok(())
     }
 
     /// Pins the `label` to the given `instr` if unpinned.
     pub fn try_pin_label(&mut self, label: LabelRef, instr: Instr) {
-        let label = &mut self.labels[label.0];
-        if !label.is_pinned() {
-            *label = Label::Pinned(instr)
+        if let unpinned @ Label::Unpinned = self.get_label_mut(label) {
+            *unpinned = Label::Pinned(instr)
         }
     }
 
@@ -102,7 +116,7 @@ impl LabelRegistry {
     ///
     /// If the `label` is unpinned.
     pub fn resolve_label(&self, label: LabelRef) -> Result<Instr, LabelError> {
-        match &self.labels[label.0] {
+        match self.get_label(label) {
             Label::Pinned(instr) => Ok(*instr),
             Label::Unpinned => Err(LabelError::Unpinned { label }),
         }

From f7bb9338b069d2ae9abe23174d87e3676bcb9b27 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Tue, 27 Sep 2022 14:42:59 +0200
Subject: [PATCH 10/15] add BranchParams and BranchOffset types

---
 crates/wasmi/src/engine/bytecode/mod.rs       |  2 +
 crates/wasmi/src/engine/bytecode/utils.rs     | 76 +++++++++++++++++++
 .../src/engine/func_builder/inst_builder.rs   |  7 +-
 3 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/crates/wasmi/src/engine/bytecode/mod.rs b/crates/wasmi/src/engine/bytecode/mod.rs
index cdeeae2c07..a355d855d1 100644
--- a/crates/wasmi/src/engine/bytecode/mod.rs
+++ b/crates/wasmi/src/engine/bytecode/mod.rs
@@ -13,6 +13,8 @@ pub use self::utils::{
     LocalDepth,
     Offset,
     SignatureIdx,
+    BranchOffset,
+    BranchParams,
 };
 use core::fmt::Debug;
 use wasmi_core::UntypedValue;
diff --git a/crates/wasmi/src/engine/bytecode/utils.rs b/crates/wasmi/src/engine/bytecode/utils.rs
index 077db25883..335c081726 100644
--- a/crates/wasmi/src/engine/bytecode/utils.rs
+++ b/crates/wasmi/src/engine/bytecode/utils.rs
@@ -1,4 +1,5 @@
 use core::fmt::Display;
+use crate::engine::Instr;
 
 /// Defines how many stack values are going to be dropped and kept after branching.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -168,3 +169,78 @@ impl Offset {
         self.0
     }
 }
+
+/// A branching target.
+///
+/// This also specifies how many values on the stack
+/// need to be dropped and kept in order to maintain
+/// value stack integrity.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct BranchParams {
+    /// The branching offset.
+    ///
+    /// How much instruction pointer is offset upon taking the branch.
+    offset: BranchOffset,
+    /// How many values on the stack need to be dropped and kept.
+    drop_keep: DropKeep,
+}
+
+impl BranchParams {
+    /// Creates uninitialized [`BranchParams`].
+    pub fn uninit(drop_keep: DropKeep) -> Self {
+        Self { offset: BranchOffset::uninit(), drop_keep }
+    }
+
+    /// Returns `true` if the [`BranchParams`] have been initialized already.
+    pub fn is_init(&self) -> bool {
+        self.offset.is_init()
+    }
+
+    /// Initializes the [`BranchParams`] with a proper [`BranchOffset`].
+    ///
+    /// # Panics
+    ///
+    /// - If the [`BranchParams`] have already been initialized.
+    /// - If the given [`BranchOffset`] is not properly initialized.
+    pub fn init(&mut self, offset: BranchOffset) {
+        assert!(!offset.is_init());
+        assert!(self.offset.is_init());
+        self.offset = offset;
+    }
+
+    /// Returns the branching offset.
+    pub fn offset(self) -> BranchOffset {
+        self.offset
+    }
+
+    /// Returns the amount of stack values to drop and keep upon taking the branch.
+    pub fn drop_keep(self) -> DropKeep {
+        self.drop_keep
+    }
+}
+
+/// The branching offset.
+///
+/// This defines how much the instruction pointer is offset
+/// upon taking the respective branch.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct BranchOffset(i32);
+
+impl BranchOffset {
+    /// Creates an uninitalized [`BranchOffset`].
+    pub fn uninit() -> Self {
+        Self(0)
+    }
+
+    /// Creates an initialized [`BranchOffset`] from `src` to `dst`.
+    pub fn init(src: Instr, dst: Instr) -> Self {
+        let src = src.into_u32() as i32;
+        let dst = dst.into_u32() as i32;
+        Self(dst - src)
+    }
+
+    /// Returns `true` if the [`BranchOffset`] has been initialized.
+    pub fn is_init(self) -> bool {
+        self.0 != 0
+    }
+}
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 43ee07bd0e..58300ccf8c 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -38,10 +38,15 @@ impl Instr {
         Self(value)
     }
 
-    /// Returns the underlying `usize` value of the instruction index.
+    /// Returns an `usize` representation of the instruction index.
     pub fn into_usize(self) -> usize {
         self.0 as usize
     }
+
+    /// Returns an `u32` representation of the instruction index.
+    pub fn into_u32(self) -> u32 {
+        self.0
+    }
 }
 
 /// The relative depth of a Wasm branching target.

From 3fc068a7a45263dbc84cf1a46c784e429f18e352 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Tue, 27 Sep 2022 14:43:26 +0200
Subject: [PATCH 11/15] add LabelUser type and LabelRegistry::try_resolve_label
 method

---
 .../wasmi/src/engine/func_builder/labels.rs   | 39 ++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/crates/wasmi/src/engine/func_builder/labels.rs b/crates/wasmi/src/engine/func_builder/labels.rs
index 4611c8238d..deb2230358 100644
--- a/crates/wasmi/src/engine/func_builder/labels.rs
+++ b/crates/wasmi/src/engine/func_builder/labels.rs
@@ -1,3 +1,5 @@
+use crate::engine::bytecode::BranchOffset;
+
 use super::Instr;
 use alloc::vec::Vec;
 use core::fmt::{self, Display};
@@ -29,6 +31,23 @@ impl LabelRef {
 #[derive(Debug, Default)]
 pub struct LabelRegistry {
     labels: Vec<Label>,
+    users: Vec<LabelUser>,
+}
+
+/// A user of a label.
+#[derive(Debug)]
+pub struct LabelUser {
+    /// The label in use by the user.
+    label: LabelRef,
+    /// The reference to the using instruction.
+    user: Instr,
+}
+
+impl LabelUser {
+    /// Creates a new [`LabelUser`].
+    pub fn new(label: LabelRef, user: Instr) -> Self {
+        Self { label, user }
+    }
 }
 
 /// An error that may occur while operating on the [`LabelRegistry`].
@@ -59,7 +78,8 @@ impl Display for LabelError {
 impl LabelRegistry {
     /// Resets the [`LabelRegistry`] for reuse.
     pub fn reset(&mut self) {
-        self.labels.clear()
+        self.labels.clear();
+        self.users.clear();
     }
 
     /// Allocates a new unpinned [`Label`].
@@ -121,4 +141,21 @@ impl LabelRegistry {
             Label::Unpinned => Err(LabelError::Unpinned { label }),
         }
     }
+
+    /// Tries to resolve the `label`.
+    ///
+    /// Returns the proper `BranchOffset` in case the `label` has already been
+    /// pinned and returns an uninitialized `BranchOffset` otherwise.
+    ///
+    /// In case the `label` has not yet been pinned the `user` is registered
+    /// for deferred label resolution.
+    pub fn try_resolve_label(&mut self, label: LabelRef, user: Instr) -> BranchOffset {
+        match *self.get_label(label) {
+            Label::Pinned(target) => BranchOffset::init(user, target),
+            Label::Unpinned => {
+                self.users.push(LabelUser::new(label, user));
+                BranchOffset::uninit()
+            }
+        }
+    }
 }

From b4b69b4b3713cfc4fe575d0709c598c21ec2719b Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Tue, 27 Sep 2022 22:54:22 +0200
Subject: [PATCH 12/15] implement BranchParams and BranchOffset abstractions

This makes Instruction again a non-generic type.
Label users are now stored again but in a single Vec to allow for proper heap memory reuse.
Branch targets are now branch offsets since that is going to support a single instruction pointer design in the future.
---
 crates/wasmi/src/engine/bytecode/mod.rs       |  26 +-
 crates/wasmi/src/engine/bytecode/utils.rs     |  19 +-
 crates/wasmi/src/engine/code_map.rs           |  12 +-
 crates/wasmi/src/engine/executor.rs           |  66 +----
 .../src/engine/func_builder/inst_builder.rs   | 264 ++++--------------
 .../wasmi/src/engine/func_builder/labels.rs   |  72 ++++-
 crates/wasmi/src/engine/func_builder/mod.rs   | 106 +++----
 crates/wasmi/src/engine/mod.rs                |  12 +-
 crates/wasmi/src/module/tests.rs              |  10 +-
 9 files changed, 194 insertions(+), 393 deletions(-)

diff --git a/crates/wasmi/src/engine/bytecode/mod.rs b/crates/wasmi/src/engine/bytecode/mod.rs
index a355d855d1..63bab7f686 100644
--- a/crates/wasmi/src/engine/bytecode/mod.rs
+++ b/crates/wasmi/src/engine/bytecode/mod.rs
@@ -6,6 +6,8 @@ mod utils;
 mod tests;
 
 pub use self::utils::{
+    BranchOffset,
+    BranchParams,
     DropKeep,
     DropKeepError,
     FuncIdx,
@@ -13,18 +15,10 @@ pub use self::utils::{
     LocalDepth,
     Offset,
     SignatureIdx,
-    BranchOffset,
-    BranchParams,
 };
 use core::fmt::Debug;
 use wasmi_core::UntypedValue;
 
-/// Internal types of an [`Instruction`] type.
-pub trait InstructionTypes {
-    /// A branching target.
-    type BranchParams: Debug + Copy + Clone + PartialEq + Eq;
-}
-
 /// The internal `wasmi` bytecode that is stored for Wasm functions.
 ///
 /// # Note
@@ -34,16 +28,13 @@ pub trait InstructionTypes {
 /// For example the `BrTable` instruction is unrolled into separate instructions
 /// each representing either the `BrTable` head or one of its branching targets.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Instruction<T>
-where
-    T: InstructionTypes,
-{
+pub enum Instruction {
     LocalGet { local_depth: LocalDepth },
     LocalSet { local_depth: LocalDepth },
     LocalTee { local_depth: LocalDepth },
-    Br(<T as InstructionTypes>::BranchParams),
-    BrIfEqz(<T as InstructionTypes>::BranchParams),
-    BrIfNez(<T as InstructionTypes>::BranchParams),
+    Br(BranchParams),
+    BrIfEqz(BranchParams),
+    BrIfNez(BranchParams),
     ReturnIfNez(DropKeep),
     BrTable { len_targets: usize },
     Unreachable,
@@ -218,10 +209,7 @@ where
     I64TruncSatF64U,
 }
 
-impl<T> Instruction<T>
-where
-    T: InstructionTypes,
-{
+impl Instruction {
     /// Creates a new `Const` instruction from the given value.
     pub fn constant<C>(value: C) -> Self
     where
diff --git a/crates/wasmi/src/engine/bytecode/utils.rs b/crates/wasmi/src/engine/bytecode/utils.rs
index 335c081726..20f75fbdc5 100644
--- a/crates/wasmi/src/engine/bytecode/utils.rs
+++ b/crates/wasmi/src/engine/bytecode/utils.rs
@@ -1,5 +1,5 @@
-use core::fmt::Display;
 use crate::engine::Instr;
+use core::fmt::Display;
 
 /// Defines how many stack values are going to be dropped and kept after branching.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -186,13 +186,13 @@ pub struct BranchParams {
 }
 
 impl BranchParams {
-    /// Creates uninitialized [`BranchParams`].
-    pub fn uninit(drop_keep: DropKeep) -> Self {
-        Self { offset: BranchOffset::uninit(), drop_keep }
+    /// Creates new [`BranchParams`].
+    pub fn new(offset: BranchOffset, drop_keep: DropKeep) -> Self {
+        Self { offset, drop_keep }
     }
 
     /// Returns `true` if the [`BranchParams`] have been initialized already.
-    pub fn is_init(&self) -> bool {
+    fn is_init(&self) -> bool {
         self.offset.is_init()
     }
 
@@ -203,8 +203,8 @@ impl BranchParams {
     /// - If the [`BranchParams`] have already been initialized.
     /// - If the given [`BranchOffset`] is not properly initialized.
     pub fn init(&mut self, offset: BranchOffset) {
-        assert!(!offset.is_init());
-        assert!(self.offset.is_init());
+        assert!(offset.is_init());
+        assert!(!self.is_init());
         self.offset = offset;
     }
 
@@ -243,4 +243,9 @@ impl BranchOffset {
     pub fn is_init(self) -> bool {
         self.0 != 0
     }
+
+    /// Returns the `i32` representation of the [`BranchOffset`].
+    pub fn into_i32(self) -> i32 {
+        self.0
+    }
 }
diff --git a/crates/wasmi/src/engine/code_map.rs b/crates/wasmi/src/engine/code_map.rs
index bbe7675df0..60e43fc9f3 100644
--- a/crates/wasmi/src/engine/code_map.rs
+++ b/crates/wasmi/src/engine/code_map.rs
@@ -1,6 +1,6 @@
 //! Datastructure to efficiently store function bodies and their instructions.
 
-use super::{super::Index, executor::ExecInstruction};
+use super::{super::Index, Instruction};
 use alloc::vec::Vec;
 
 /// A reference to a Wasm function body stored in the [`CodeMap`].
@@ -73,7 +73,7 @@ pub struct CodeMap {
     ///
     /// Also this improves efficiency of deallocating the [`CodeMap`]
     /// and generally improves data locality.
-    insts: Vec<ExecInstruction>,
+    insts: Vec<Instruction>,
 }
 
 impl CodeMap {
@@ -84,7 +84,7 @@ impl CodeMap {
     /// instructions.
     pub fn alloc<I>(&mut self, len_locals: usize, max_stack_height: usize, insts: I) -> FuncBody
     where
-        I: IntoIterator<Item = ExecInstruction>,
+        I: IntoIterator<Item = Instruction>,
     {
         let start = self.insts.len();
         self.insts.extend(insts);
@@ -116,7 +116,7 @@ impl CodeMap {
 /// The instructions of a resolved [`FuncBody`].
 #[derive(Debug, Copy, Clone)]
 pub struct Instructions<'a> {
-    insts: &'a [ExecInstruction],
+    insts: &'a [Instruction],
 }
 
 impl<'a> Instructions<'a> {
@@ -126,7 +126,7 @@ impl<'a> Instructions<'a> {
     ///
     /// If there is no instruction at the given index.
     #[cfg(test)]
-    pub fn get(&self, index: usize) -> Option<&ExecInstruction> {
+    pub fn get(&self, index: usize) -> Option<&Instruction> {
         self.insts.get(index)
     }
 
@@ -136,7 +136,7 @@ impl<'a> Instructions<'a> {
     ///
     /// Panics in debug mode if the `pc` is invalid for the [`Instructions`].
     #[inline(always)]
-    pub unsafe fn get_release_unchecked(&self, pc: usize) -> &'a ExecInstruction {
+    pub unsafe fn get_release_unchecked(&self, pc: usize) -> &'a Instruction {
         debug_assert!(
             self.insts.get(pc).is_some(),
             "unexpectedly missing instruction at index {pc}",
diff --git a/crates/wasmi/src/engine/executor.rs b/crates/wasmi/src/engine/executor.rs
index 4145d8bff3..8274289180 100644
--- a/crates/wasmi/src/engine/executor.rs
+++ b/crates/wasmi/src/engine/executor.rs
@@ -1,14 +1,6 @@
 use super::{
     super::{Memory, Table},
-    bytecode::{
-        FuncIdx,
-        GlobalIdx,
-        Instruction,
-        InstructionTypes,
-        LocalDepth,
-        Offset,
-        SignatureIdx,
-    },
+    bytecode::{BranchParams, FuncIdx, GlobalIdx, Instruction, LocalDepth, Offset, SignatureIdx},
     cache::InstanceCache,
     code_map::Instructions,
     stack::ValueStackRef,
@@ -16,7 +8,6 @@ use super::{
     CallOutcome,
     DropKeep,
     FuncFrame,
-    Instr,
     ValueStack,
 };
 use crate::{
@@ -28,47 +19,6 @@ use crate::{
 use core::cmp;
 use wasmi_core::{memory_units::Pages, ExtendInto, LittleEndianConvert, UntypedValue, WrapInto};
 
-/// Base implementer for executable [`InstructionTypes`].
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ExecInstructionTypes {}
-
-impl InstructionTypes for ExecInstructionTypes {
-    type BranchParams = ExecBranchParams;
-}
-
-/// An executable compiled [`Instruction`].
-pub type ExecInstruction = Instruction<ExecInstructionTypes>;
-
-/// A branching target.
-///
-/// This also specifies how many values on the stack
-/// need to be dropped and kept in order to maintain
-/// value stack integrity.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct ExecBranchParams {
-    /// The target instruction to branch to.
-    target: Instr,
-    /// How many values on the stack need to be dropped and kept.
-    drop_keep: DropKeep,
-}
-
-impl ExecBranchParams {
-    /// Creates new branching parameters.
-    pub fn new(target: Instr, drop_keep: DropKeep) -> Self {
-        Self { target, drop_keep }
-    }
-
-    /// Returns the branching target.
-    pub fn target(self) -> Instr {
-        self.target
-    }
-
-    /// Returns the amount of stack values to drop and keep upon taking the branch.
-    pub fn drop_keep(self) -> DropKeep {
-        self.drop_keep
-    }
-}
-
 /// Executes the given function `frame`.
 ///
 /// # Note
@@ -324,9 +274,9 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         }
     }
 
-    /// Returns the [`ExecInstruction`] at the current program counter.
+    /// Returns the [`Instruction`] at the current program counter.
     #[inline(always)]
-    fn instr(&self) -> &'engine ExecInstruction {
+    fn instr(&self) -> &'engine Instruction {
         // # Safety
         //
         // Properly constructed `wasmi` bytecode can never produce invalid `pc`.
@@ -536,9 +486,9 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         self.pc += 1;
     }
 
-    fn branch_to(&mut self, target: ExecBranchParams) {
+    fn branch_to(&mut self, target: BranchParams) {
         self.value_stack.drop_keep(target.drop_keep());
-        self.pc = target.target().into_usize();
+        self.pc = (self.pc as isize + target.offset().into_i32() as isize) as usize;
     }
 
     fn sync_stack_ptr(&mut self) {
@@ -569,11 +519,11 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         Err(TrapCode::Unreachable).map_err(Into::into)
     }
 
-    fn visit_br(&mut self, target: ExecBranchParams) {
+    fn visit_br(&mut self, target: BranchParams) {
         self.branch_to(target)
     }
 
-    fn visit_br_if_eqz(&mut self, target: ExecBranchParams) {
+    fn visit_br_if_eqz(&mut self, target: BranchParams) {
         let condition = self.value_stack.pop_as();
         if condition {
             self.next_instr()
@@ -582,7 +532,7 @@ impl<'ctx, 'engine, 'func, HostData> Executor<'ctx, 'engine, 'func, HostData> {
         }
     }
 
-    fn visit_br_if_nez(&mut self, target: ExecBranchParams) {
+    fn visit_br_if_nez(&mut self, target: BranchParams) {
         let condition = self.value_stack.pop_as();
         if condition {
             self.branch_to(target)
diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 58300ccf8c..8d4057cad9 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -1,15 +1,10 @@
 //! Abstractions to build up instructions forming Wasm function bodies.
 
-use super::{
-    labels::{LabelRef, LabelRegistry},
-    IrBranchParams,
-    IrInstruction,
-};
+use super::labels::{LabelRef, LabelRegistry};
 use crate::engine::{
-    executor::{ExecBranchParams, ExecInstruction},
+    bytecode::{BranchOffset, Instruction},
     Engine,
     FuncBody,
-    Instruction,
 };
 use alloc::vec::Vec;
 
@@ -19,7 +14,7 @@ use alloc::vec::Vec;
 pub struct Instr(u32);
 
 impl Instr {
-    /// Creates an [`InstructionIdx`] from the given `usize` value.
+    /// Creates an [`Instr`] from the given `usize` value.
     ///
     /// # Note
     ///
@@ -27,11 +22,11 @@ impl Instr {
     ///
     /// # Panics
     ///
-    /// If the `value` exceeds limitations for [`InstructionIdx`].
+    /// If the `value` exceeds limitations for [`Instr`].
     pub fn from_usize(value: usize) -> Self {
         let value = value.try_into().unwrap_or_else(|error| {
             panic!(
-                "encountered invalid value of {} for `InstructionIdx`: {}",
+                "invalid index {} for instruction reference: {}",
                 value, error
             )
         });
@@ -43,6 +38,11 @@ impl Instr {
         self.0 as usize
     }
 
+    /// Creates an [`Instr`] form the given `u32` value.
+    pub fn from_u32(value: u32) -> Self {
+        Self(value)
+    }
+
     /// Returns an `u32` representation of the instruction index.
     pub fn into_u32(self) -> u32 {
         self.0
@@ -73,7 +73,7 @@ impl RelativeDepth {
 #[derive(Debug, Default)]
 pub struct InstructionsBuilder {
     /// The instructions of the partially constructed function body.
-    insts: Vec<IrInstruction>,
+    insts: Vec<Instruction>,
     /// All labels and their uses.
     labels: LabelRegistry,
 }
@@ -128,12 +128,29 @@ impl InstructionsBuilder {
     /// Pushes the internal instruction bytecode to the [`InstructionsBuilder`].
     ///
     /// Returns an [`InstructionIdx`] to refer to the pushed instruction.
-    pub fn push_inst(&mut self, inst: IrInstruction) -> Instr {
+    pub fn push_inst(&mut self, inst: Instruction) -> Instr {
         let idx = self.current_pc();
         self.insts.push(inst);
         idx
     }
 
+    /// Try resolving the `label` for the currently constructed instruction.
+    ///
+    /// Returns an uninitialized [`BranchOffset`] if the `label` cannot yet
+    /// be resolved and defers resolution to later.
+    pub fn try_resolve_label(&mut self, label: LabelRef) -> BranchOffset {
+        let user = self.current_pc();
+        self.try_resolve_label_for(label, user)
+    }
+
+    /// Try resolving the `label` for the given `instr`.
+    ///
+    /// Returns an uninitialized [`BranchOffset`] if the `label` cannot yet
+    /// be resolved and defers resolution to later.
+    pub fn try_resolve_label_for(&mut self, label: LabelRef, instr: Instr) -> BranchOffset {
+        self.labels.try_resolve_label(label, instr)
+    }
+
     /// Finishes construction of the function body instructions.
     ///
     /// # Note
@@ -149,210 +166,37 @@ impl InstructionsBuilder {
         len_locals: usize,
         max_stack_height: usize,
     ) -> FuncBody {
-        engine.alloc_func_body(
-            len_locals,
-            max_stack_height,
-            self.insts
-                .drain(..)
-                .map(|instr| instr.compile(&self.labels)),
-        )
+        self.update_branch_offsets();
+        engine.alloc_func_body(len_locals, max_stack_height, self.insts.drain(..))
     }
-}
 
-impl IrBranchParams {
-    /// Compiles the [`IrBranchParams`] to an [`ExecBranchParams`].
-    fn compile(self, labels: &LabelRegistry) -> ExecBranchParams {
-        ExecBranchParams::new(
-            labels
-                .resolve_label(self.target())
-                .unwrap_or_else(|err| panic!("failed to resolve label: {err}")),
-            self.drop_keep(),
-        )
+    /// Updates the branch offsets of all branch instructions inplace.
+    ///
+    /// # Panics
+    ///
+    /// If this is used before all branching labels have been pinned.
+    fn update_branch_offsets(&mut self) {
+        for (user, offset) in self.labels.resolved_users() {
+            self.insts[user.into_usize()].update_branch_offset(offset);
+        }
     }
 }
 
-impl IrInstruction {
-    /// Compiles the [`IrInstruction`] to an [`ExecInstruction`].
-    fn compile(self, labels: &LabelRegistry) -> ExecInstruction {
+impl Instruction {
+    /// Updates the [`BranchOffset`] for the branch [`Instruction].
+    ///
+    /// # Panics
+    ///
+    /// If `self` is not a branch [`Instruction`].
+    pub fn update_branch_offset(&mut self, offset: BranchOffset) {
         match self {
-            Self::LocalGet { local_depth } => Instruction::LocalGet { local_depth },
-            Self::LocalSet { local_depth } => Instruction::LocalSet { local_depth },
-            Self::LocalTee { local_depth } => Instruction::LocalTee { local_depth },
-            Self::Br(target) => Instruction::Br(target.compile(labels)),
-            Self::BrIfEqz(target) => Instruction::BrIfEqz(target.compile(labels)),
-            Self::BrIfNez(target) => Instruction::BrIfNez(target.compile(labels)),
-            Self::ReturnIfNez(drop_keep) => Instruction::ReturnIfNez(drop_keep),
-            Self::BrTable { len_targets } => Instruction::BrTable { len_targets },
-            Self::Unreachable => Instruction::Unreachable,
-            Self::Return(drop_keep) => Instruction::Return(drop_keep),
-            Self::Call(func_idx) => Instruction::Call(func_idx),
-            Self::CallIndirect(func_type_idx) => Instruction::CallIndirect(func_type_idx),
-            Self::Drop => Instruction::Drop,
-            Self::Select => Instruction::Select,
-            Self::GlobalGet(global_idx) => Instruction::GlobalGet(global_idx),
-            Self::GlobalSet(global_idx) => Instruction::GlobalSet(global_idx),
-            Self::I32Load(offset) => Instruction::I32Load(offset),
-            Self::I64Load(offset) => Instruction::I64Load(offset),
-            Self::F32Load(offset) => Instruction::F32Load(offset),
-            Self::F64Load(offset) => Instruction::F64Load(offset),
-            Self::I32Load8S(offset) => Instruction::I32Load8S(offset),
-            Self::I32Load8U(offset) => Instruction::I32Load8U(offset),
-            Self::I32Load16S(offset) => Instruction::I32Load16S(offset),
-            Self::I32Load16U(offset) => Instruction::I32Load16U(offset),
-            Self::I64Load8S(offset) => Instruction::I64Load8S(offset),
-            Self::I64Load8U(offset) => Instruction::I64Load8U(offset),
-            Self::I64Load16S(offset) => Instruction::I64Load16S(offset),
-            Self::I64Load16U(offset) => Instruction::I64Load16U(offset),
-            Self::I64Load32S(offset) => Instruction::I64Load32S(offset),
-            Self::I64Load32U(offset) => Instruction::I64Load32U(offset),
-            Self::I32Store(offset) => Instruction::I32Store(offset),
-            Self::I64Store(offset) => Instruction::I64Store(offset),
-            Self::F32Store(offset) => Instruction::F32Store(offset),
-            Self::F64Store(offset) => Instruction::F64Store(offset),
-            Self::I32Store8(offset) => Instruction::I32Store8(offset),
-            Self::I32Store16(offset) => Instruction::I32Store16(offset),
-            Self::I64Store8(offset) => Instruction::I64Store8(offset),
-            Self::I64Store16(offset) => Instruction::I64Store16(offset),
-            Self::I64Store32(offset) => Instruction::I64Store32(offset),
-            Self::MemorySize => Instruction::MemorySize,
-            Self::MemoryGrow => Instruction::MemoryGrow,
-            Self::Const(value) => Instruction::Const(value),
-            Self::I32Eqz => Instruction::I32Eqz,
-            Self::I32Eq => Instruction::I32Eq,
-            Self::I32Ne => Instruction::I32Ne,
-            Self::I32LtS => Instruction::I32LtS,
-            Self::I32LtU => Instruction::I32LtU,
-            Self::I32GtS => Instruction::I32GtS,
-            Self::I32GtU => Instruction::I32GtU,
-            Self::I32LeS => Instruction::I32LeS,
-            Self::I32LeU => Instruction::I32LeU,
-            Self::I32GeS => Instruction::I32GeS,
-            Self::I32GeU => Instruction::I32GeU,
-            Self::I64Eqz => Instruction::I64Eqz,
-            Self::I64Eq => Instruction::I64Eq,
-            Self::I64Ne => Instruction::I64Ne,
-            Self::I64LtS => Instruction::I64LtS,
-            Self::I64LtU => Instruction::I64LtU,
-            Self::I64GtS => Instruction::I64GtS,
-            Self::I64GtU => Instruction::I64GtU,
-            Self::I64LeS => Instruction::I64LeS,
-            Self::I64LeU => Instruction::I64LeU,
-            Self::I64GeS => Instruction::I64GeS,
-            Self::I64GeU => Instruction::I64GeU,
-            Self::F32Eq => Instruction::F32Eq,
-            Self::F32Ne => Instruction::F32Ne,
-            Self::F32Lt => Instruction::F32Lt,
-            Self::F32Gt => Instruction::F32Gt,
-            Self::F32Le => Instruction::F32Le,
-            Self::F32Ge => Instruction::F32Ge,
-            Self::F64Eq => Instruction::F64Eq,
-            Self::F64Ne => Instruction::F64Ne,
-            Self::F64Lt => Instruction::F64Lt,
-            Self::F64Gt => Instruction::F64Gt,
-            Self::F64Le => Instruction::F64Le,
-            Self::F64Ge => Instruction::F64Ge,
-            Self::I32Clz => Instruction::I32Clz,
-            Self::I32Ctz => Instruction::I32Ctz,
-            Self::I32Popcnt => Instruction::I32Popcnt,
-            Self::I32Add => Instruction::I32Add,
-            Self::I32Sub => Instruction::I32Sub,
-            Self::I32Mul => Instruction::I32Mul,
-            Self::I32DivS => Instruction::I32DivS,
-            Self::I32DivU => Instruction::I32DivU,
-            Self::I32RemS => Instruction::I32RemS,
-            Self::I32RemU => Instruction::I32RemU,
-            Self::I32And => Instruction::I32And,
-            Self::I32Or => Instruction::I32Or,
-            Self::I32Xor => Instruction::I32Xor,
-            Self::I32Shl => Instruction::I32Shl,
-            Self::I32ShrS => Instruction::I32ShrS,
-            Self::I32ShrU => Instruction::I32ShrU,
-            Self::I32Rotl => Instruction::I32Rotl,
-            Self::I32Rotr => Instruction::I32Rotr,
-            Self::I64Clz => Instruction::I64Clz,
-            Self::I64Ctz => Instruction::I64Ctz,
-            Self::I64Popcnt => Instruction::I64Popcnt,
-            Self::I64Add => Instruction::I64Add,
-            Self::I64Sub => Instruction::I64Sub,
-            Self::I64Mul => Instruction::I64Mul,
-            Self::I64DivS => Instruction::I64DivS,
-            Self::I64DivU => Instruction::I64DivU,
-            Self::I64RemS => Instruction::I64RemS,
-            Self::I64RemU => Instruction::I64RemU,
-            Self::I64And => Instruction::I64And,
-            Self::I64Or => Instruction::I64Or,
-            Self::I64Xor => Instruction::I64Xor,
-            Self::I64Shl => Instruction::I64Shl,
-            Self::I64ShrS => Instruction::I64ShrS,
-            Self::I64ShrU => Instruction::I64ShrU,
-            Self::I64Rotl => Instruction::I64Rotl,
-            Self::I64Rotr => Instruction::I64Rotr,
-            Self::F32Abs => Instruction::F32Abs,
-            Self::F32Neg => Instruction::F32Neg,
-            Self::F32Ceil => Instruction::F32Ceil,
-            Self::F32Floor => Instruction::F32Floor,
-            Self::F32Trunc => Instruction::F32Trunc,
-            Self::F32Nearest => Instruction::F32Nearest,
-            Self::F32Sqrt => Instruction::F32Sqrt,
-            Self::F32Add => Instruction::F32Add,
-            Self::F32Sub => Instruction::F32Sub,
-            Self::F32Mul => Instruction::F32Mul,
-            Self::F32Div => Instruction::F32Div,
-            Self::F32Min => Instruction::F32Min,
-            Self::F32Max => Instruction::F32Max,
-            Self::F32Copysign => Instruction::F32Copysign,
-            Self::F64Abs => Instruction::F64Abs,
-            Self::F64Neg => Instruction::F64Neg,
-            Self::F64Ceil => Instruction::F64Ceil,
-            Self::F64Floor => Instruction::F64Floor,
-            Self::F64Trunc => Instruction::F64Trunc,
-            Self::F64Nearest => Instruction::F64Nearest,
-            Self::F64Sqrt => Instruction::F64Sqrt,
-            Self::F64Add => Instruction::F64Add,
-            Self::F64Sub => Instruction::F64Sub,
-            Self::F64Mul => Instruction::F64Mul,
-            Self::F64Div => Instruction::F64Div,
-            Self::F64Min => Instruction::F64Min,
-            Self::F64Max => Instruction::F64Max,
-            Self::F64Copysign => Instruction::F64Copysign,
-            Self::I32WrapI64 => Instruction::I32WrapI64,
-            Self::I32TruncSF32 => Instruction::I32TruncSF32,
-            Self::I32TruncUF32 => Instruction::I32TruncUF32,
-            Self::I32TruncSF64 => Instruction::I32TruncSF64,
-            Self::I32TruncUF64 => Instruction::I32TruncUF64,
-            Self::I64ExtendSI32 => Instruction::I64ExtendSI32,
-            Self::I64ExtendUI32 => Instruction::I64ExtendUI32,
-            Self::I64TruncSF32 => Instruction::I64TruncSF32,
-            Self::I64TruncUF32 => Instruction::I64TruncUF32,
-            Self::I64TruncSF64 => Instruction::I64TruncSF64,
-            Self::I64TruncUF64 => Instruction::I64TruncUF64,
-            Self::F32ConvertSI32 => Instruction::F32ConvertSI32,
-            Self::F32ConvertUI32 => Instruction::F32ConvertUI32,
-            Self::F32ConvertSI64 => Instruction::F32ConvertSI64,
-            Self::F32ConvertUI64 => Instruction::F32ConvertUI64,
-            Self::F32DemoteF64 => Instruction::F32DemoteF64,
-            Self::F64ConvertSI32 => Instruction::F64ConvertSI32,
-            Self::F64ConvertUI32 => Instruction::F64ConvertUI32,
-            Self::F64ConvertSI64 => Instruction::F64ConvertSI64,
-            Self::F64ConvertUI64 => Instruction::F64ConvertUI64,
-            Self::F64PromoteF32 => Instruction::F64PromoteF32,
-            Self::I32ReinterpretF32 => Instruction::I32ReinterpretF32,
-            Self::I64ReinterpretF64 => Instruction::I64ReinterpretF64,
-            Self::F32ReinterpretI32 => Instruction::F32ReinterpretI32,
-            Self::F64ReinterpretI64 => Instruction::F64ReinterpretI64,
-            Self::I32Extend8S => Instruction::I32Extend8S,
-            Self::I32Extend16S => Instruction::I32Extend16S,
-            Self::I64Extend8S => Instruction::I64Extend8S,
-            Self::I64Extend16S => Instruction::I64Extend16S,
-            Self::I64Extend32S => Instruction::I64Extend32S,
-            Self::I32TruncSatF32S => Instruction::I32TruncSatF32S,
-            Self::I32TruncSatF32U => Instruction::I32TruncSatF32U,
-            Self::I32TruncSatF64S => Instruction::I32TruncSatF64S,
-            Self::I32TruncSatF64U => Instruction::I32TruncSatF64U,
-            Self::I64TruncSatF32S => Instruction::I64TruncSatF32S,
-            Self::I64TruncSatF32U => Instruction::I64TruncSatF32U,
-            Self::I64TruncSatF64S => Instruction::I64TruncSatF64S,
-            Self::I64TruncSatF64U => Instruction::I64TruncSatF64U,
+            Instruction::Br(params)
+            | Instruction::BrIfEqz(params)
+            | Instruction::BrIfNez(params) => params.init(offset),
+            _ => panic!(
+                "tried to update branch offset of a non-branch instruction: {:?}",
+                self
+            ),
         }
     }
 }
diff --git a/crates/wasmi/src/engine/func_builder/labels.rs b/crates/wasmi/src/engine/func_builder/labels.rs
index deb2230358..68f2875ac3 100644
--- a/crates/wasmi/src/engine/func_builder/labels.rs
+++ b/crates/wasmi/src/engine/func_builder/labels.rs
@@ -1,8 +1,10 @@
-use crate::engine::bytecode::BranchOffset;
-
 use super::Instr;
+use crate::engine::bytecode::BranchOffset;
 use alloc::vec::Vec;
-use core::fmt::{self, Display};
+use core::{
+    fmt::{self, Display},
+    slice::Iter as SliceIter,
+};
 
 /// A label during the `wasmi` compilation process.
 #[derive(Debug, Copy, Clone)]
@@ -130,18 +132,6 @@ impl LabelRegistry {
         }
     }
 
-    /// Resolves a `label` to its pinned [`Instr`].
-    ///
-    /// # Errors
-    ///
-    /// If the `label` is unpinned.
-    pub fn resolve_label(&self, label: LabelRef) -> Result<Instr, LabelError> {
-        match self.get_label(label) {
-            Label::Pinned(instr) => Ok(*instr),
-            Label::Unpinned => Err(LabelError::Unpinned { label }),
-        }
-    }
-
     /// Tries to resolve the `label`.
     ///
     /// Returns the proper `BranchOffset` in case the `label` has already been
@@ -158,4 +148,56 @@ impl LabelRegistry {
             }
         }
     }
+
+    /// Resolves a `label` to its pinned [`Instr`].
+    ///
+    /// # Errors
+    ///
+    /// If the `label` is unpinned.
+    fn resolve_label(&self, label: LabelRef) -> Result<Instr, LabelError> {
+        match self.get_label(label) {
+            Label::Pinned(instr) => Ok(*instr),
+            Label::Unpinned => Err(LabelError::Unpinned { label }),
+        }
+    }
+
+    /// Returns an iterator over pairs of user [`Instr`] and their [`BranchOffset`].
+    ///
+    /// # Panics
+    ///
+    /// If used before all used branching labels have been pinned.
+    pub fn resolved_users(&self) -> ResolvedUserIter {
+        ResolvedUserIter {
+            users: self.users.iter(),
+            registry: self,
+        }
+    }
+}
+
+/// Iterator over resolved label users.
+///
+/// Iterates over pairs of user [`Instr`] and its respective [`BranchOffset`]
+/// which allows the [`InstructionsBuilder`] to properly update the branching
+/// offsets.
+///
+/// [`InstructionsBuilder`]: [`super::InstructionsBuilder`]
+#[derive(Debug)]
+pub struct ResolvedUserIter<'a> {
+    users: SliceIter<'a, LabelUser>,
+    registry: &'a LabelRegistry,
+}
+
+impl<'a> Iterator for ResolvedUserIter<'a> {
+    type Item = (Instr, BranchOffset);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next = self.users.next()?;
+        let src = next.user;
+        let dst = self
+            .registry
+            .resolve_label(next.label)
+            .unwrap_or_else(|err| panic!("failed to resolve user: {err}"));
+        let offset = BranchOffset::init(src, dst);
+        Some((src, offset))
+    }
 }
diff --git a/crates/wasmi/src/engine/func_builder/mod.rs b/crates/wasmi/src/engine/func_builder/mod.rs
index e65f57158f..15509ae209 100644
--- a/crates/wasmi/src/engine/func_builder/mod.rs
+++ b/crates/wasmi/src/engine/func_builder/mod.rs
@@ -25,9 +25,9 @@ pub use self::{
     error::TranslationError,
     inst_builder::{Instr, InstructionsBuilder, RelativeDepth},
 };
-use super::{bytecode::InstructionTypes, DropKeep, FuncBody, Instruction};
+use super::{DropKeep, FuncBody, Instruction};
 use crate::{
-    engine::bytecode::Offset,
+    engine::bytecode::{BranchParams, Offset},
     module::{
         BlockType,
         FuncIdx,
@@ -49,47 +49,6 @@ use wasmi_core::{Value, ValueType, F32, F64};
 /// The used function validator type.
 type FuncValidator = wasmparser::FuncValidator<wasmparser::ValidatorResources>;
 
-/// Base implementer for intermeidate representation (IR) [`InstructionTypes`].
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum IrInstructionTypes {}
-
-impl InstructionTypes for IrInstructionTypes {
-    type BranchParams = IrBranchParams;
-}
-
-/// An intermediate representation [`Instruction`].
-pub type IrInstruction = Instruction<IrInstructionTypes>;
-
-/// A branching target.
-///
-/// This also specifies how many values on the stack
-/// need to be dropped and kept in order to maintain
-/// value stack integrity.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct IrBranchParams {
-    /// The label that refers to the branching target.
-    target: LabelRef,
-    /// How many values on the stack need to be dropped and kept.
-    drop_keep: DropKeep,
-}
-
-impl IrBranchParams {
-    /// Creates new branching parameters.
-    pub fn new(target: LabelRef, drop_keep: DropKeep) -> Self {
-        Self { target, drop_keep }
-    }
-
-    /// Returns the branching target.
-    pub fn target(self) -> LabelRef {
-        self.target
-    }
-
-    /// Returns the amount of stack values to drop and keep upon taking the branch.
-    pub fn drop_keep(self) -> DropKeep {
-        self.drop_keep
-    }
-}
-
 /// The interface to translate a `wasmi` bytecode function using Wasm bytecode.
 pub struct FuncBuilder<'parser> {
     /// The [`Engine`] for which the function is translated.
@@ -130,7 +89,7 @@ pub struct FunctionBuilderAllocations {
     /// Stores and resolves local variable types.
     locals: LocalsRegistry,
     /// Buffer for translating `br_table`.
-    br_table_branches: Vec<IrInstruction>,
+    br_table_branches: Vec<Instruction>,
 }
 
 impl FunctionBuilderAllocations {
@@ -378,6 +337,11 @@ impl<'parser> FuncBuilder<'parser> {
             Ok(AcquiredTarget::Branch(label, drop_keep))
         }
     }
+
+    /// Creates [`BranchParams`] to `target` using `drop_keep` for the current instruction.
+    fn branch_params(&mut self, target: LabelRef, drop_keep: DropKeep) -> BranchParams {
+        BranchParams::new(self.alloc.inst_builder.try_resolve_label(target), drop_keep)
+    }
 }
 
 /// An acquired target.
@@ -509,10 +473,10 @@ impl<'parser> FuncBuilder<'parser> {
                 else_label,
                 stack_height,
             ));
-            let branch_target = IrBranchParams::new(else_label, DropKeep::none());
+            let branch_params = self.branch_params(else_label, DropKeep::none());
             self.alloc
                 .inst_builder
-                .push_inst(Instruction::BrIfEqz(branch_target));
+                .push_inst(Instruction::BrIfEqz(branch_params));
         } else {
             self.alloc
                 .control_frames
@@ -551,8 +515,8 @@ impl<'parser> FuncBuilder<'parser> {
         // Create the jump from the end of the `then` block to the `if`
         // block's end label in case the end of `then` is reachable.
         if reachable {
-            let target = IrBranchParams::new(if_frame.end_label(), DropKeep::none());
-            self.alloc.inst_builder.push_inst(Instruction::Br(target));
+            let params = self.branch_params(if_frame.end_label(), DropKeep::none());
+            self.alloc.inst_builder.push_inst(Instruction::Br(params));
         }
         // Now resolve labels for the instructions of the `else` block
         self.alloc.inst_builder.pin_label(if_frame.else_label());
@@ -614,10 +578,11 @@ impl<'parser> FuncBuilder<'parser> {
         self.translate_if_reachable(|builder| {
             match builder.acquire_target(relative_depth)? {
                 AcquiredTarget::Branch(end_label, drop_keep) => {
+                    let params = builder.branch_params(end_label, drop_keep);
                     builder
                         .alloc
                         .inst_builder
-                        .push_inst(Instruction::Br(IrBranchParams::new(end_label, drop_keep)));
+                        .push_inst(Instruction::Br(params));
                 }
                 AcquiredTarget::Return(_) => {
                     // In this case the `br` can be directly translated as `return`.
@@ -636,9 +601,11 @@ impl<'parser> FuncBuilder<'parser> {
             debug_assert_eq!(condition, ValueType::I32);
             match builder.acquire_target(relative_depth)? {
                 AcquiredTarget::Branch(end_label, drop_keep) => {
-                    builder.alloc.inst_builder.push_inst(Instruction::BrIfNez(
-                        IrBranchParams::new(end_label, drop_keep),
-                    ));
+                    let params = builder.branch_params(end_label, drop_keep);
+                    builder
+                        .alloc
+                        .inst_builder
+                        .push_inst(Instruction::BrIfNez(params));
                 }
                 AcquiredTarget::Return(drop_keep) => {
                     builder
@@ -657,13 +624,22 @@ impl<'parser> FuncBuilder<'parser> {
         table: wasmparser::BrTable<'parser>,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
-            fn compute_inst(
+            fn offset_instr(base: Instr, offset: usize) -> Instr {
+                Instr::from_u32(base.into_u32() + offset as u32)
+            }
+
+            fn compute_instr(
                 builder: &mut FuncBuilder,
+                n: usize,
                 depth: RelativeDepth,
-            ) -> Result<IrInstruction, TranslationError> {
+            ) -> Result<Instruction, TranslationError> {
                 match builder.acquire_target(depth.into_u32())? {
                     AcquiredTarget::Branch(label, drop_keep) => {
-                        Ok(Instruction::Br(IrBranchParams::new(label, drop_keep)))
+                        let base = builder.alloc.inst_builder.current_pc();
+                        let instr = offset_instr(base, n + 1);
+                        let offset = builder.alloc.inst_builder.try_resolve_label_for(label, instr);
+                        let params = BranchParams::new(offset, drop_keep);
+                        Ok(Instruction::Br(params))
                     }
                     AcquiredTarget::Return(drop_keep) => Ok(Instruction::Return(drop_keep)),
                 }
@@ -686,14 +662,14 @@ impl<'parser> FuncBuilder<'parser> {
             debug_assert_eq!(case, ValueType::I32);
 
             builder.alloc.br_table_branches.clear();
-            for depth in targets.into_iter() {
-                let relative_depth = compute_inst(builder, depth)?;
+            for (n, depth) in targets.into_iter().enumerate() {
+                let relative_depth = compute_instr(builder, n, depth)?;
                 builder.alloc.br_table_branches.push(relative_depth);
             }
 
             // We include the default target in `len_branches`.
             let len_branches = builder.alloc.br_table_branches.len();
-            let default_branch = compute_inst(builder, default)?;
+            let default_branch = compute_instr(builder, len_branches, default)?;
             builder.alloc.inst_builder.push_inst(Instruction::BrTable {
                 len_targets: len_branches + 1,
             });
@@ -913,7 +889,7 @@ impl<'parser> FuncBuilder<'parser> {
         &mut self,
         memarg: wasmparser::MemArg,
         loaded_type: ValueType,
-        make_inst: fn(Offset) -> IrInstruction,
+        make_inst: fn(Offset) -> Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (memory_idx, offset) = Self::decompose_memarg(memarg);
@@ -1058,7 +1034,7 @@ impl<'parser> FuncBuilder<'parser> {
         &mut self,
         memarg: wasmparser::MemArg,
         stored_value: ValueType,
-        make_inst: fn(Offset) -> IrInstruction,
+        make_inst: fn(Offset) -> Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (memory_idx, offset) = Self::decompose_memarg(memarg);
@@ -1242,7 +1218,7 @@ impl<'parser> FuncBuilder<'parser> {
     fn translate_unary_cmp(
         &mut self,
         input_type: ValueType,
-        inst: IrInstruction,
+        inst: Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let condition = builder.alloc.value_stack.pop1();
@@ -1273,7 +1249,7 @@ impl<'parser> FuncBuilder<'parser> {
     fn translate_binary_cmp(
         &mut self,
         input_type: ValueType,
-        inst: IrInstruction,
+        inst: Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (v0, v1) = builder.alloc.value_stack.pop2();
@@ -1469,7 +1445,7 @@ impl<'parser> FuncBuilder<'parser> {
     pub fn translate_unary_operation(
         &mut self,
         value_type: ValueType,
-        inst: IrInstruction,
+        inst: Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let actual_type = builder.alloc.value_stack.top();
@@ -1518,7 +1494,7 @@ impl<'parser> FuncBuilder<'parser> {
     pub fn translate_binary_operation(
         &mut self,
         value_type: ValueType,
-        inst: IrInstruction,
+        inst: Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let (v0, v1) = builder.alloc.value_stack.pop2();
@@ -1855,7 +1831,7 @@ impl<'parser> FuncBuilder<'parser> {
         &mut self,
         input_type: ValueType,
         output_type: ValueType,
-        inst: IrInstruction,
+        inst: Instruction,
     ) -> Result<(), TranslationError> {
         self.translate_if_reachable(|builder| {
             let input = builder.alloc.value_stack.pop1();
diff --git a/crates/wasmi/src/engine/mod.rs b/crates/wasmi/src/engine/mod.rs
index 75b60d4b79..ada155a51e 100644
--- a/crates/wasmi/src/engine/mod.rs
+++ b/crates/wasmi/src/engine/mod.rs
@@ -30,7 +30,7 @@ use self::{
     bytecode::Instruction,
     cache::InstanceCache,
     code_map::CodeMap,
-    executor::{execute_frame, ExecInstruction},
+    executor::execute_frame,
     func_types::FuncTypeRegistry,
     stack::{FuncFrame, Stack, ValueStack},
 };
@@ -152,7 +152,7 @@ impl Engine {
         insts: I,
     ) -> FuncBody
     where
-        I: IntoIterator<Item = ExecInstruction>,
+        I: IntoIterator<Item = Instruction>,
         I::IntoIter: ExactSizeIterator,
     {
         self.inner
@@ -172,11 +172,7 @@ impl Engine {
     ///
     /// If the [`FuncBody`] is invalid for the [`Engine`].
     #[cfg(test)]
-    pub(crate) fn resolve_inst(
-        &self,
-        func_body: FuncBody,
-        index: usize,
-    ) -> Option<ExecInstruction> {
+    pub(crate) fn resolve_inst(&self, func_body: FuncBody, index: usize) -> Option<Instruction> {
         let this = self.inner.lock();
         let iref = this.code_map.header(func_body).iref();
         this.code_map.insts(iref).get(index).copied()
@@ -259,7 +255,7 @@ impl EngineInner {
         insts: I,
     ) -> FuncBody
     where
-        I: IntoIterator<Item = ExecInstruction>,
+        I: IntoIterator<Item = Instruction>,
         I::IntoIter: ExactSizeIterator,
     {
         self.code_map.alloc(len_locals, max_stack_height, insts)
diff --git a/crates/wasmi/src/module/tests.rs b/crates/wasmi/src/module/tests.rs
index d159d55d5d..9326c0bfce 100644
--- a/crates/wasmi/src/module/tests.rs
+++ b/crates/wasmi/src/module/tests.rs
@@ -1,8 +1,7 @@
 use super::*;
 use crate::{
     engine::{
-        bytecode::Instruction,
-        executor::{ExecBranchParams, ExecInstruction},
+        bytecode::{BranchParams, Instruction},
         DropKeep,
         Instr,
     },
@@ -36,7 +35,7 @@ fn assert_func_body<E>(
     func_body: FuncBody,
     expected_instructions: E,
 ) where
-    E: IntoIterator<Item = ExecInstruction>,
+    E: IntoIterator<Item = Instruction>,
     <E as IntoIterator>::IntoIter: ExactSizeIterator,
 {
     let expected_instructions = expected_instructions.into_iter();
@@ -80,7 +79,7 @@ fn assert_func_body<E>(
 fn assert_func_bodies<E, T>(wasm_bytes: impl AsRef<[u8]>, expected: E)
 where
     E: IntoIterator<Item = T>,
-    T: IntoIterator<Item = ExecInstruction>,
+    T: IntoIterator<Item = Instruction>,
     <T as IntoIterator>::IntoIter: ExactSizeIterator,
 {
     let wasm_bytes = wasm_bytes.as_ref();
@@ -299,7 +298,8 @@ fn drop_locals() {
 
 macro_rules! target {
     ( $inst_idx:expr, drop: $drop:expr, keep: $keep:expr ) => {
-        ExecBranchParams::new(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
+        // BranchParams::init(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
+        todo!() // TODO
     };
 }
 

From ec81eb4f325ddc0f33ffd757d429ac68ec28af40 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Tue, 27 Sep 2022 23:12:43 +0200
Subject: [PATCH 13/15] fix unit tests

---
 crates/wasmi/src/engine/bytecode/utils.rs |  6 ++
 crates/wasmi/src/module/tests.rs          | 74 +++++++++++------------
 2 files changed, 42 insertions(+), 38 deletions(-)

diff --git a/crates/wasmi/src/engine/bytecode/utils.rs b/crates/wasmi/src/engine/bytecode/utils.rs
index 20f75fbdc5..4a6257a6a1 100644
--- a/crates/wasmi/src/engine/bytecode/utils.rs
+++ b/crates/wasmi/src/engine/bytecode/utils.rs
@@ -227,6 +227,12 @@ impl BranchParams {
 pub struct BranchOffset(i32);
 
 impl BranchOffset {
+    /// Creates a [`BranchOffset`] from the given raw `i32` value.
+    #[cfg(test)]
+    pub fn from_i32(value: i32) -> Self {
+        Self(value)
+    }
+
     /// Creates an uninitalized [`BranchOffset`].
     pub fn uninit() -> Self {
         Self(0)
diff --git a/crates/wasmi/src/module/tests.rs b/crates/wasmi/src/module/tests.rs
index 9326c0bfce..5ff638373c 100644
--- a/crates/wasmi/src/module/tests.rs
+++ b/crates/wasmi/src/module/tests.rs
@@ -1,9 +1,8 @@
 use super::*;
 use crate::{
     engine::{
-        bytecode::{BranchParams, Instruction},
+        bytecode::{BranchOffset, BranchParams, Instruction},
         DropKeep,
-        Instr,
     },
     Engine,
 };
@@ -296,10 +295,9 @@ fn drop_locals() {
     assert_func_bodies(&wasm, [expected]);
 }
 
-macro_rules! target {
-    ( $inst_idx:expr, drop: $drop:expr, keep: $keep:expr ) => {
-        // BranchParams::init(Instr::from_usize($inst_idx), drop_keep($drop, $keep))
-        todo!() // TODO
+macro_rules! params {
+    ( $src:expr => $dst:expr, drop: $drop:expr, keep: $keep:expr ) => {
+        BranchParams::new(BranchOffset::from_i32($dst - $src), drop_keep($drop, $keep))
     };
 }
 
@@ -321,7 +319,7 @@ fn if_without_else() {
     );
     let expected = [
         /* 0 */ Instruction::constant(1),
-        /* 1 */ Instruction::BrIfEqz(target!(4, drop: 0, keep: 0)),
+        /* 1 */ Instruction::BrIfEqz(params!(1 => 4, drop: 0, keep: 0)),
         /* 2 */ Instruction::constant(2),
         /* 3 */ Instruction::Return(drop_keep(1, 1)),
         /* 4 */ Instruction::constant(3),
@@ -350,14 +348,14 @@ fn if_else() {
     "#,
     );
     let expected = [
-        Instruction::constant(1),
-        Instruction::BrIfEqz(target!(5, drop: 0, keep: 0)),
-        Instruction::constant(2),
-        Instruction::local_set(1),
-        Instruction::Br(target!(7, drop: 0, keep: 0)),
-        Instruction::constant(3),
-        Instruction::local_set(1),
-        Instruction::Return(drop_keep(1, 0)),
+        /* 0 */ Instruction::constant(1),
+        /* 1 */ Instruction::BrIfEqz(params!(1 => 5, drop: 0, keep: 0)),
+        /* 2 */ Instruction::constant(2),
+        /* 3 */ Instruction::local_set(1),
+        /* 4 */ Instruction::Br(params!(4 => 7, drop: 0, keep: 0)),
+        /* 5 */ Instruction::constant(3),
+        /* 6 */ Instruction::local_set(1),
+        /* 7 */ Instruction::Return(drop_keep(1, 0)),
     ];
     assert_func_bodies(&wasm, [expected]);
 }
@@ -381,9 +379,9 @@ fn if_else_returns_result() {
     );
     let expected = [
         /* 0 */ Instruction::constant(1),
-        /* 1 */ Instruction::BrIfEqz(target!(4, drop: 0, keep: 0)),
+        /* 1 */ Instruction::BrIfEqz(params!(1 => 4, drop: 0, keep: 0)),
         /* 2 */ Instruction::constant(2),
-        /* 3 */ Instruction::Br(target!(5, drop: 0, keep: 0)),
+        /* 3 */ Instruction::Br(params!(3 => 5, drop: 0, keep: 0)),
         /* 4 */ Instruction::constant(3),
         /* 5 */ Instruction::Drop,
         /* 6 */ Instruction::Return(drop_keep(0, 0)),
@@ -414,13 +412,13 @@ fn if_else_branch_from_true_branch() {
     );
     let expected = [
         /*  0 */ Instruction::constant(1),
-        /*  1 */ Instruction::BrIfEqz(target!(8, drop: 0, keep: 0)),
+        /*  1 */ Instruction::BrIfEqz(params!(1 => 8, drop: 0, keep: 0)),
         /*  2 */ Instruction::constant(1),
         /*  3 */ Instruction::constant(1),
-        /*  4 */ Instruction::BrIfNez(target!(9, drop: 0, keep: 1)),
+        /*  4 */ Instruction::BrIfNez(params!(4 => 9, drop: 0, keep: 1)),
         /*  5 */ Instruction::Drop,
         /*  6 */ Instruction::constant(2),
-        /*  7 */ Instruction::Br(target!(9, drop: 0, keep: 0)),
+        /*  7 */ Instruction::Br(params!(7 => 9, drop: 0, keep: 0)),
         /*  8 */ Instruction::constant(3),
         /*  9 */ Instruction::Drop,
         /* 10 */ Instruction::Return(drop_keep(0, 0)),
@@ -451,12 +449,12 @@ fn if_else_branch_from_false_branch() {
     );
     let expected = [
         /*  0 */ Instruction::constant(1),
-        /*  1 */ Instruction::BrIfEqz(target!(4, drop: 0, keep: 0)),
+        /*  1 */ Instruction::BrIfEqz(params!(1 => 4, drop: 0, keep: 0)),
         /*  2 */ Instruction::constant(1),
-        /*  3 */ Instruction::Br(target!(9, drop: 0, keep: 0)),
+        /*  3 */ Instruction::Br(params!(3 => 9, drop: 0, keep: 0)),
         /*  4 */ Instruction::constant(2),
         /*  5 */ Instruction::constant(1),
-        /*  6 */ Instruction::BrIfNez(target!(9, drop: 0, keep: 1)),
+        /*  6 */ Instruction::BrIfNez(params!(6 => 9, drop: 0, keep: 1)),
         /*  7 */ Instruction::Drop,
         /*  8 */ Instruction::constant(3),
         /*  9 */ Instruction::Drop,
@@ -489,7 +487,7 @@ fn if_else_both_unreachable_before_end() {
     );
     let expected = [
         /* 0 */ Instruction::local_get(1),
-        /* 1 */ Instruction::BrIfEqz(target!(4, drop: 0, keep: 0)),
+        /* 1 */ Instruction::BrIfEqz(params!(1 => 4, drop: 0, keep: 0)),
         /* 2 */ Instruction::constant(1),
         /* 3 */ Instruction::Return(drop_keep(1, 1)),
         /* 4 */ Instruction::constant(2),
@@ -518,11 +516,11 @@ fn loop_() {
     "#,
     );
     let expected = [
-        Instruction::constant(1),
-        Instruction::BrIfNez(target!(0, drop: 0, keep: 0)),
-        Instruction::constant(2),
-        Instruction::Drop,
-        Instruction::Return(drop_keep(0, 0)),
+        /* 0 */ Instruction::constant(1),
+        /* 1 */ Instruction::BrIfNez(params!(1 => 0, drop: 0, keep: 0)),
+        /* 2 */ Instruction::constant(2),
+        /* 3 */ Instruction::Drop,
+        /* 4 */ Instruction::Return(drop_keep(0, 0)),
     ];
     assert_func_bodies(&wasm, [expected]);
 }
@@ -568,8 +566,8 @@ fn spec_as_br_if_value_cond() {
         /* 1 */ Instruction::constant(9),
         /* 2 */ Instruction::constant(0),
         /* 3 */ Instruction::BrTable { len_targets: 2 },
-        /* 4 */ Instruction::Br(target!(6, drop: 1, keep: 1)),
-        /* 5 */ Instruction::Br(target!(6, drop: 1, keep: 1)),
+        /* 4 */ Instruction::Br(params!(4 => 6, drop: 1, keep: 1)),
+        /* 5 */ Instruction::Br(params!(5 => 6, drop: 1, keep: 1)),
         /* 6 */ Instruction::Return(drop_keep(0, 1)),
     ];
     assert_func_bodies(&wasm, [expected]);
@@ -594,8 +592,8 @@ fn br_table() {
     let expected = [
         /* 0 */ Instruction::constant(0),
         /* 1 */ Instruction::BrTable { len_targets: 2 },
-        /* 2 */ Instruction::Br(target!(0, drop: 0, keep: 0)),
-        /* 3 */ Instruction::Br(target!(4, drop: 0, keep: 0)),
+        /* 2 */ Instruction::Br(params!(2 => 0, drop: 0, keep: 0)),
+        /* 3 */ Instruction::Br(params!(3 => 4, drop: 0, keep: 0)),
         /* 4 */ Instruction::Return(drop_keep(0, 0)),
     ];
     assert_func_bodies(&wasm, [expected]);
@@ -624,8 +622,8 @@ fn br_table_returns_result() {
         /* 0 */ Instruction::constant(0),
         /* 1 */ Instruction::constant(1),
         /* 2 */ Instruction::BrTable { len_targets: 2 },
-        /* 3 */ Instruction::Br(target!(5, drop: 0, keep: 1)),
-        /* 4 */ Instruction::Br(target!(6, drop: 0, keep: 1)),
+        /* 3 */ Instruction::Br(params!(3 => 5, drop: 0, keep: 1)),
+        /* 4 */ Instruction::Br(params!(4 => 6, drop: 0, keep: 1)),
         /* 5 */ Instruction::Unreachable,
         /* 6 */ Instruction::Drop,
         /* 7 */ Instruction::Return(drop_keep(0, 0)),
@@ -653,7 +651,7 @@ fn wabt_example() {
     );
     let expected = [
         /* 0 */ Instruction::local_get(1),
-        /* 1 */ Instruction::BrIfNez(target!(4, drop: 0, keep: 0)),
+        /* 1 */ Instruction::BrIfNez(params!(1 => 4, drop: 0, keep: 0)),
         /* 2 */ Instruction::constant(1),
         /* 3 */ Instruction::Return(drop_keep(1, 1)),
         /* 4 */ Instruction::constant(2),
@@ -719,8 +717,8 @@ fn br_table_return() {
     let expected = [
         /* 0 */ Instruction::local_get(1),
         /* 1 */ Instruction::BrTable { len_targets: 3 },
-        /* 2 */ Instruction::Br(target!(5, drop: 0, keep: 0)),
-        /* 3 */ Instruction::Br(target!(5, drop: 0, keep: 0)),
+        /* 2 */ Instruction::Br(params!(2 => 5, drop: 0, keep: 0)),
+        /* 3 */ Instruction::Br(params!(3 => 5, drop: 0, keep: 0)),
         /* 4 */ Instruction::Return(drop_keep(1, 0)),
         /* 5 */ Instruction::Return(drop_keep(1, 0)),
     ];

From b2d609a51d82a61943db52ace73ce2885f8bb05a Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Tue, 27 Sep 2022 23:16:38 +0200
Subject: [PATCH 14/15] fix internal doc link

---
 crates/wasmi/src/engine/func_builder/inst_builder.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/wasmi/src/engine/func_builder/inst_builder.rs b/crates/wasmi/src/engine/func_builder/inst_builder.rs
index 8d4057cad9..c8bea8df83 100644
--- a/crates/wasmi/src/engine/func_builder/inst_builder.rs
+++ b/crates/wasmi/src/engine/func_builder/inst_builder.rs
@@ -127,7 +127,7 @@ impl InstructionsBuilder {
 
     /// Pushes the internal instruction bytecode to the [`InstructionsBuilder`].
     ///
-    /// Returns an [`InstructionIdx`] to refer to the pushed instruction.
+    /// Returns an [`Instr`] to refer to the pushed instruction.
     pub fn push_inst(&mut self, inst: Instruction) -> Instr {
         let idx = self.current_pc();
         self.insts.push(inst);

From 6d6037059d365f7c754b9010a14e6d10e3e42a63 Mon Sep 17 00:00:00 2001
From: Robin Freyler <robin.freyler@gmail.com>
Date: Tue, 27 Sep 2022 23:30:58 +0200
Subject: [PATCH 15/15] add back proper size_of_instruction unit test

---
 crates/wasmi/src/engine/bytecode/tests.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/wasmi/src/engine/bytecode/tests.rs b/crates/wasmi/src/engine/bytecode/tests.rs
index e018cd042b..aab74cacfd 100644
--- a/crates/wasmi/src/engine/bytecode/tests.rs
+++ b/crates/wasmi/src/engine/bytecode/tests.rs
@@ -2,5 +2,8 @@ use super::*;
 
 #[test]
 fn size_of_instruction() {
+    assert_eq!(core::mem::size_of::<Instruction>(), 16);
     assert_eq!(core::mem::size_of::<DropKeep>(), 4);
+    assert_eq!(core::mem::size_of::<BranchParams>(), 8);
+    assert_eq!(core::mem::size_of::<BranchOffset>(), 4);
 }