add br_table execution handlers

Author: Robbepop

crates/wasmi/src/engine/executor/handler/dispatch.rs

@@ -371,6 +371,8 @@ pub fn op_code_to_handler(code: OpCode) -> Handler {
         OpCode::MemoryGrow => exec::memory_grow,
         // unconditional branch
         OpCode::Branch => exec::branch,
+        OpCode::BranchTable => exec::branch_table,
+        OpCode::BranchTableSpan => exec::branch_table_span,
         // unary
         OpCode::I32Popcnt_Ss => exec::i32_popcnt_ss,
         OpCode::I32Ctz_Ss => exec::i32_ctz_ss,

crates/wasmi/src/engine/executor/handler/exec.rs

@@ -10,6 +10,7 @@ use crate::{
         executor::handler::{
             state::DoneReason,
             utils::{
+                exec_copy_span,
                 exec_copy_span_asc,
                 exec_copy_span_des,
                 extract_mem0,
@@ -29,7 +30,7 @@ use crate::{
     ir::{Slot, SlotSpan},
     TrapCode,
 };
-use core::ptr::NonNull;
+use core::{cmp, ptr::NonNull};
 
 unsafe fn decode_op<Op: ir::Decode>(ip: Ip) -> (Ip, Op) {
     let ip = match cfg!(feature = "compact") {
@@ -429,6 +430,57 @@ pub fn memory_grow(
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
 
+/// Fetches the branch table index value and normalizes it to clamp between `0..len_targets`.
+fn fetch_branch_table_target(sp: Sp, index: Slot, len_targets: u32) -> usize {
+    let index: u32 = get_value(index, sp);
+    let max_index = len_targets - 1;
+    cmp::min(index, max_index) as usize
+}
+
+pub fn branch_table(
+    state: &mut VmState,
+    ip: Ip,
+    sp: Sp,
+    mem0: Mem0Ptr,
+    mem0_len: Mem0Len,
+    instance: NonNull<InstanceEntity>,
+) -> Done {
+    let (ip, crate::ir::decode::BranchTable { len_targets, index }) = unsafe { decode_op(ip) };
+    let chosen_target = fetch_branch_table_target(sp, index, len_targets);
+    let target_offset = 4 * chosen_target;
+    let ip = unsafe { ip.add(target_offset) };
+    let (_, offset) = unsafe { ip.decode::<ir::BranchOffset>() };
+    let ip = offset_ip(ip, offset);
+    dispatch!(state, ip, sp, mem0, mem0_len, instance)
+}
+
+pub fn branch_table_span(
+    state: &mut VmState,
+    ip: Ip,
+    sp: Sp,
+    mem0: Mem0Ptr,
+    mem0_len: Mem0Len,
+    instance: NonNull<InstanceEntity>,
+) -> Done {
+    let (
+        ip,
+        crate::ir::decode::BranchTableSpan {
+            len_targets,
+            index,
+            values,
+            len_values,
+        },
+    ) = unsafe { decode_op(ip) };
+    let chosen_target = fetch_branch_table_target(sp, index, len_targets);
+    let target_offset = 6 * chosen_target;
+    let ip = unsafe { ip.add(target_offset) };
+    let (_, ir::BranchTableTarget { results, offset }) =
+        unsafe { ip.decode::<ir::BranchTableTarget>() };
+    exec_copy_span(sp, results, values, len_values); // TODO: maybe provide 2 `br_table_span` operation variants if possible
+    let ip = offset_ip(ip, offset);
+    dispatch!(state, ip, sp, mem0, mem0_len, instance)
+}
+
 macro_rules! handler_unary {
     ( $( fn $handler:ident($op:ident) = $eval:expr );* $(;)? ) => {
         $(

crates/wasmi/src/engine/executor/handler/utils.rs

@@ -142,6 +142,14 @@ macro_rules! exec_return {
     }};
 }
 
+pub fn exec_copy_span(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
+    let op = match dst.head() <= src.head() {
+        true => exec_copy_span_asc,
+        false => exec_copy_span_des,
+    };
+    op(sp, dst, src, len)
+}
+
 pub fn exec_copy_span_asc(sp: Sp, dst: SlotSpan, src: SlotSpan, len: u16) {
     debug_assert!(dst.head() <= src.head());
     let dst = dst.iter(len);