wasm/validation/

code.rs

use core::iter;

use alloc::collections::btree_set::BTreeSet;
use alloc::vec::Vec;

use crate::core::error::DecodingError;
use crate::core::indices::{
    read_label_idx, DataIdx, ElemIdx, ExtendedIdxVec, FuncIdx, GlobalIdx, IdxVec, LocalIdx, MemIdx,
    TableIdx, TypeIdx,
};
use crate::core::reader::section_header::{SectionHeader, SectionTy};
use crate::core::reader::span::Span;
use crate::core::reader::types::element::ElemType;
use crate::core::reader::types::global::Global;
use crate::core::reader::types::memarg::MemArg;
use crate::core::reader::types::{BlockType, FuncType, MemType, NumType, TableType, ValType};
use crate::core::reader::WasmReader;
use crate::core::sidetable::{Sidetable, SidetableEntry};
use crate::core::utils::ToUsizeExt;
use crate::validation_stack::{LabelInfo, ValidationStack};
use crate::{RefType, ValidationError};

/// # Safety
///
/// The caller must ensure that all index values passed into this function are
/// valid in the relevant `IdxVec`. The following table lists all index types
/// and their respective `IdxVec` types:
///
/// | Index | `IdxVec` |
/// | ----- | -------- |
/// | [`TypeIdx`] | [`IdxVec<TypeIdx, FuncType>`] |
/// | [`FuncIdx`] | [`IdxVec<FuncIdx, TypeIdx>`] contained in [`ExtendedIdxVec<FuncIdx, TypeIdx>`] |
/// | [`TableIdx`] | [`IdxVec<TableIdx, TableType>`] |
#[allow(clippy::too_many_arguments)]
pub unsafe fn validate_code_section(
    wasm: &mut WasmReader,
    section_header: SectionHeader,
    fn_types: &IdxVec<TypeIdx, FuncType>,
    c_funcs: &ExtendedIdxVec<FuncIdx, TypeIdx>,
    c_globals: &IdxVec<GlobalIdx, Global>,
    c_mems: &IdxVec<MemIdx, MemType>,
    data_count: Option<u32>,
    c_tables: &IdxVec<TableIdx, TableType>,
    c_elems: &IdxVec<ElemIdx, ElemType>,
    validation_context_refs: &BTreeSet<FuncIdx>,
    sidetable: &mut Sidetable,
) -> Result<Vec<(Span, usize)>, ValidationError> {
    assert_eq!(section_header.ty, SectionTy::Code);
    let code_block_spans_stps = wasm.read_vec_enumerated(|wasm, idx| {
        // We need to offset the index by the number of functions that were
        // imported. Imported functions always live at the start of the index
        // space.
        let ty_idx = c_funcs
            .iter_local_definitions()
            .nth(idx.into_usize())
            .ok_or(ValidationError::FunctionAndCodeSectionsHaveDifferentLengths)?;

        // SAFETY: The caller ensures that all passed `TypeIdx` values,
        // including this one, are valid in this `IdxVec<TypeIdx, FuncType>`.
        let func_ty: FuncType = unsafe { fn_types.get(*ty_idx).clone() };

        let func_size = wasm.read_var_u32()?;
        let func_block = wasm.make_span(func_size.into_usize())?;
        let previous_pc = wasm.pc;

        let locals = {
            let params = func_ty.params.valtypes.iter().cloned();
            let declared_locals = read_declared_locals(wasm)?;
            params.chain(declared_locals).collect::<Vec<ValType>>()
        };

        let mut stack = ValidationStack::new_for_func(func_ty);
        let stp = sidetable.len();

        // SAFETY: The caller ensures the same safety requirements for the same
        // unmodified index values.
        unsafe {
            read_instructions(
                wasm,
                &mut stack,
                sidetable,
                &locals,
                c_globals,
                fn_types,
                c_funcs.inner(),
                c_mems,
                data_count,
                c_tables,
                c_elems,
                validation_context_refs,
            )
        }?;

        // Check if there were unread trailing instructions after the last END
        if previous_pc + func_size.into_usize() != wasm.pc {
            return Err(ValidationError::CodeExprHasTrailingInstructions);
        }

        Ok((func_block, stp))
    })?;

    trace!(
        "Read code section. Found {} code blocks",
        code_block_spans_stps.len()
    );

    Ok(code_block_spans_stps)
}

pub fn read_declared_locals(wasm: &mut WasmReader) -> Result<Vec<ValType>, DecodingError> {
    let locals = wasm.read_vec(|wasm| {
        let n = wasm.read_var_u32()?.into_usize();
        let valtype = ValType::read(wasm)?;

        Ok((n, valtype))
    })?;

    // these checks are related to the official test suite binary.wast file, the first 2 assert_malformed's starting at line 350
    // we check to not have more than 2^32-1 locals, and if that number is okay, we then get to instantiate them all
    // this is because the flat_map and collect take an insane amount of time
    // in total, these 2 tests take more than 240s
    let mut total_no_of_locals: u64 = 0;
    for local in &locals {
        let temp = local.0 as u64;
        if temp > u32::MAX.into() {
            return Err(DecodingError::TooManyLocals(total_no_of_locals));
        };
        total_no_of_locals = match total_no_of_locals.checked_add(temp) {
            None => return Err(DecodingError::TooManyLocals(total_no_of_locals)),
            Some(n) => n,
        }
    }

    if total_no_of_locals > u32::MAX.into() {
        return Err(DecodingError::TooManyLocals(total_no_of_locals));
    }

    // Flatten local types for easier representation where n > 1
    let locals = locals
        .into_iter()
        .flat_map(|entry| iter::repeat_n(entry.1, entry.0))
        .collect::<Vec<ValType>>();

    Ok(locals)
}

/// Validates a specific branch to some label by its index `label_idx`.
/// Branches are generated by branching instructions and some can even generate multiple branches.
fn validate_branch_and_generate_sidetable_entry(
    _wasm: &WasmReader,
    label_idx: u32,
    stack: &mut ValidationStack,
    sidetable: &mut Sidetable,
    unify_to_expected_types: bool,
) -> Result<(), ValidationError> {
    stack.assert_val_types_of_label_jump_types_on_top(label_idx, unify_to_expected_types)?;

    // Get stack length before we mutably borrow the label's `CtrlStackEntry`.
    let stack_len = stack.len();

    let index_of_label_in_ctrl_stack = stack
        .ctrl_stack
        .len()
        .checked_sub(label_idx.into_usize())
        .and_then(|i| i.checked_sub(1));

    let targeted_ctrl_block_entry = index_of_label_in_ctrl_stack
        .and_then(|idx| stack.ctrl_stack.get_mut(idx))
        .ok_or(ValidationError::InvalidLabelIdx(label_idx))?;

    let valcnt = targeted_ctrl_block_entry.label_types().len();
    let popcnt = stack_len - targeted_ctrl_block_entry.height - valcnt;

    // Now we generate the actual sidetable entry.
    //
    // This entry needs to be backpatched later, except for when it targets a label generated
    // by a `loop` instruction. This is because loops are the only instruction able to perform
    // backwards jumps, so we already know the exact instruction and sidetable pointers for that label.
    // For all other types of labels (blocks, ifs, functions) we generate a partial sidetable entry.
    //
    // This partial sidetable entry temporarily stores dummy values in the `pc` and `stp` fields until we reach
    // the `end` of this label's scope,
    let stp_here = sidetable.len();
    sidetable.push(SidetableEntry {
        pc: usize::MAX,
        stp: usize::MAX,
        popcnt,
        valcnt,
    });

    match &mut targeted_ctrl_block_entry.label_info {
        LabelInfo::Block { stps_to_backpatch } => stps_to_backpatch.push(stp_here),
        LabelInfo::Loop { ip, stp } => {
            //we already know where to jump to for loops
            sidetable[stp_here].pc = *ip;
            sidetable[stp_here].stp = *stp;
        }
        LabelInfo::If {
            stps_to_backpatch, ..
        } => stps_to_backpatch.push(stp_here),
        LabelInfo::Func { stps_to_backpatch } => stps_to_backpatch.push(stp_here),
        LabelInfo::Untyped => {
            unreachable!("this label is for untyped wasm sequences")
        }
    }
    Ok(())
}

/// # Safety
///
/// The caller must ensure that all index values passed into this function are
/// valid in the relevant `IdxVec`. The following table lists all index types
/// and their respective `IdxVec` types:
///
/// | Index | `IdxVec` |
/// |-------|----------|
/// | [`TypeIdx`] | [`IdxVec<TypeIdx, FuncType>`] |
/// | [`FuncIdx`] | [`IdxVec<FuncIdx, TypeIdx>`] |
/// | [`TableIdx`] | [`IdxVec<TableIdx, TableType>`] |
#[allow(clippy::too_many_arguments)]
unsafe fn read_instructions(
    wasm: &mut WasmReader,
    stack: &mut ValidationStack,
    sidetable: &mut Sidetable,
    locals: &[ValType],
    c_globals: &IdxVec<GlobalIdx, Global>,
    fn_types: &IdxVec<TypeIdx, FuncType>,
    c_funcs: &IdxVec<FuncIdx, TypeIdx>,
    c_mems: &IdxVec<MemIdx, MemType>,
    data_count: Option<u32>,
    c_tables: &IdxVec<TableIdx, TableType>,
    c_elems: &IdxVec<ElemIdx, ElemType>,
    validation_context_refs: &BTreeSet<FuncIdx>,
) -> Result<(), ValidationError> {
    loop {
        let Ok(first_instr_byte) = wasm.read_u8() else {
            // TODO only do this if EOF
            return Err(ValidationError::ExprMissingEnd);
        };

        #[cfg(feature = "log")]
        crate::core::utils::print_beautiful_instruction_name_1_byte(first_instr_byte, wasm.pc);

        use crate::core::reader::types::opcode::*;
        match first_instr_byte {
            // nop: [] -> []
            NOP => {}
            // block: [] -> [t*2]
            BLOCK => {
                let block_ty = {
                    let block_ty = BlockType::read_and_validate(wasm, fn_types)?;
                    // SAFETY: The block type was just validated using the same
                    // `IdxVec<TypeIdx, FuncType>`.
                    unsafe { block_ty.as_func_type(fn_types) }?
                };
                let label_info = LabelInfo::Block {
                    stps_to_backpatch: Vec::new(),
                };
                // The types are explicitly popped and pushed in
                // https://webassembly.github.io/spec/core/appendix/algorithm.html
                // therefore types on the stack might change.
                stack.assert_push_ctrl(label_info, block_ty, true)?;
            }
            LOOP => {
                let block_ty = {
                    let block_ty = BlockType::read_and_validate(wasm, fn_types)?;
                    // SAFETY: The block type was just validated using the same
                    // `IdxVec<TypeIdx, FuncType>`.
                    unsafe { block_ty.as_func_type(fn_types) }?
                };
                let label_info = LabelInfo::Loop {
                    ip: wasm.pc,
                    stp: sidetable.len(),
                };
                // The types are explicitly popped and pushed in
                // https://webassembly.github.io/spec/core/appendix/algorithm.html
                // therefore types on the stack might change.
                stack.assert_push_ctrl(label_info, block_ty, true)?;
            }
            IF => {
                let block_ty = {
                    let block_ty = BlockType::read_and_validate(wasm, fn_types)?;
                    // SAFETY: The block type was just validated using the same
                    // `IdxVec<TypeIdx, FuncType>`.
                    unsafe { block_ty.as_func_type(fn_types) }?
                };

                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                let stp_here = sidetable.len();
                sidetable.push(SidetableEntry {
                    pc: usize::MAX,
                    stp: usize::MAX,
                    popcnt: 0,
                    valcnt: block_ty.params.valtypes.len(),
                });

                let label_info = LabelInfo::If {
                    stp: stp_here,
                    stps_to_backpatch: Vec::new(),
                };
                // The types are explicitly popped and pushed in
                // https://webassembly.github.io/spec/core/appendix/algorithm.html
                // therefore types on the stack might change.
                stack.assert_push_ctrl(label_info, block_ty, true)?;
            }
            ELSE => {
                let (mut label_info, block_ty) = stack.assert_pop_ctrl(true)?;
                if let LabelInfo::If {
                    stp,
                    stps_to_backpatch,
                } = &mut label_info
                {
                    if *stp == usize::MAX {
                        //this If was previously matched with an else already, it is already backpatched!
                        return Err(ValidationError::ElseWithoutMatchingIf);
                    }
                    let stp_here = sidetable.len();
                    sidetable.push(SidetableEntry {
                        pc: usize::MAX,
                        stp: usize::MAX,
                        popcnt: 0,
                        valcnt: block_ty.returns.valtypes.len(),
                    });
                    stps_to_backpatch.push(stp_here);

                    sidetable[*stp].pc = wasm.pc;
                    sidetable[*stp].stp = sidetable.len();

                    *stp = usize::MAX; // mark this If as backpatched

                    for valtype in block_ty.returns.valtypes.iter().rev() {
                        stack.assert_pop_val_type(*valtype)?;
                    }

                    for valtype in block_ty.params.valtypes.iter() {
                        stack.push_valtype(*valtype);
                    }
                    // The types are explicitly popped and pushed in
                    // https://webassembly.github.io/spec/core/appendix/algorithm.html
                    // therefore types on the stack might change.
                    stack.assert_push_ctrl(label_info, block_ty, true)?;
                } else {
                    return Err(ValidationError::ElseWithoutMatchingIf);
                }
            }
            BR => {
                let label_idx = read_label_idx(wasm)?;
                validate_branch_and_generate_sidetable_entry(
                    wasm, label_idx, stack, sidetable, false,
                )?;
                stack.make_unspecified()?;
            }
            BR_IF => {
                let label_idx = read_label_idx(wasm)?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                // The types are explicitly popped and pushed in
                // https://webassembly.github.io/spec/core/appendix/algorithm.html
                // therefore types on the stack might change.
                validate_branch_and_generate_sidetable_entry(
                    wasm, label_idx, stack, sidetable, true,
                )?;
            }
            BR_TABLE => {
                let label_vec = wasm.read_vec(read_label_idx)?;
                let max_label_idx = read_label_idx(wasm)?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                for label_idx in &label_vec {
                    validate_branch_and_generate_sidetable_entry(
                        wasm, *label_idx, stack, sidetable, false,
                    )?;
                }

                validate_branch_and_generate_sidetable_entry(
                    wasm,
                    max_label_idx,
                    stack,
                    sidetable,
                    false,
                )?;

                // The label arity of the branches must be explicitly checked against each other further
                // if their arities are the same, then they must unify, as they unify against the stack variables already
                // If the following check is not made, the algorithm incorrectly unifies label types with different arities
                // in which the smaller arity type is a suffix in the label type list of the larger arity function

                // stack includes all labels, that check is made in the above fn already
                let max_label_idx = max_label_idx.into_usize();

                let max_label_arity = stack
                    .ctrl_stack
                    .get(stack.ctrl_stack.len() - max_label_idx - 1)
                    .unwrap()
                    .label_types()
                    .len();
                for label_idx in &label_vec {
                    let label_idx_as_usize = label_idx.into_usize();
                    let label_arity = stack
                        .ctrl_stack
                        .get(stack.ctrl_stack.len() - label_idx_as_usize - 1)
                        .unwrap()
                        .label_types()
                        .len();
                    if max_label_arity != label_arity {
                        return Err(ValidationError::InvalidLabelIdx(*label_idx));
                    }
                }

                stack.make_unspecified()?;
            }
            END => {
                // The types are explicitly popped and pushed in
                // https://webassembly.github.io/spec/core/appendix/algorithm.html
                // therefore types on the stack might change.
                let (label_info, block_ty) = stack.assert_pop_ctrl(true)?;
                let stp_here = sidetable.len();

                match label_info {
                    LabelInfo::Block { stps_to_backpatch } => {
                        stps_to_backpatch.iter().for_each(|i| {
                            sidetable[*i].pc = wasm.pc;
                            sidetable[*i].stp = stp_here;
                        });
                    }
                    LabelInfo::If {
                        stp,
                        stps_to_backpatch,
                    } => {
                        if stp != usize::MAX {
                            //This If is still not backpatched, meaning it does not have a corresponding
                            //ELSE. This is only allowed when the corresponding If block has the same input
                            //types as its output types (an untyped ELSE block with no instruction is valid
                            //if and only if it is of this type)
                            if !(block_ty.params == block_ty.returns) {
                                return Err(ValidationError::IfWithoutMatchingElse);
                            }

                            //This If is still not backpatched, meaning it does not have a corresponding
                            //ELSE. Therefore if its condition fails, it jumps after END.
                            sidetable[stp].pc = wasm.pc;
                            sidetable[stp].stp = stp_here;
                        }
                        stps_to_backpatch.iter().for_each(|i| {
                            sidetable[*i].pc = wasm.pc;
                            sidetable[*i].stp = stp_here;
                        });
                    }
                    LabelInfo::Loop { .. } => (),
                    LabelInfo::Func { stps_to_backpatch } => {
                        // same as blocks, except jump just before the end instr, not after it
                        // the last end instruction will handle the return to callee during execution
                        stps_to_backpatch.iter().for_each(|i| {
                            sidetable[*i].pc = wasm.pc - 1; // minus 1 is important!
                                                            // during execution we check at every END instruction whether the function body is finished
                                                            // Therefore only for function scope we jump before the END instruction
                            sidetable[*i].stp = stp_here;
                        });
                    }
                    LabelInfo::Untyped => unreachable!("this label is for untyped wasm sequences"),
                }

                if stack.ctrl_stack.is_empty() {
                    return Ok(());
                }
            }
            RETURN => {
                // Generally `return` behaves the same as `br <most_outer>`,
                // except when there are more than [`u32::MAX`] labels. In that
                // case `return` would still be valid, while `br (u32::MAX + n)`
                // is invalid.
                //
                // TODO Find a way to get rid of this limitation
                let label_idx = u32::try_from(stack.ctrl_stack.len() - 1)
                    .expect("that there are never so many nested control blocks that the index to the outermost label exceeds u32::MAX");
                validate_branch_and_generate_sidetable_entry(
                    wasm, label_idx, stack, sidetable, false,
                )?;
                stack.make_unspecified()?;
            }
            // call [t1*] -> [t2*]
            CALL => {
                let func_idx = FuncIdx::read_and_validate(wasm, c_funcs)?;
                // SAFETY: We just validated this function index with the same
                // `IdxVec`.
                let type_idx = *unsafe { c_funcs.get(func_idx) };
                // SAFETY: The caller ensures that all passed `TypeIdx` values,
                // including this one, are valid in this `IdxVec<TypeIdx,
                // FuncType>`.
                let func_ty = unsafe { fn_types.get(type_idx) };

                for typ in func_ty.params.valtypes.iter().rev() {
                    stack.assert_pop_val_type(*typ)?;
                }

                for typ in func_ty.returns.valtypes.iter() {
                    stack.push_valtype(*typ);
                }
            }
            CALL_INDIRECT => {
                let type_idx = TypeIdx::read_and_validate(wasm, fn_types)?;

                let table_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                // SAFETY: We just validated that this is a valid `TableIdx` in
                // this `IdxVec<TableIdx, TableType>`.
                let tab = unsafe { c_tables.get(table_idx) };

                if tab.et != RefType::FuncRef {
                    return Err(ValidationError::IndirectCallToNonFuncRefTable(tab.et));
                }

                // SAFETY: We just validated that this is a valid `TypeIdx` in
                // this `IdxVec<TypeIdx, FuncType>`,
                let func_ty = unsafe { fn_types.get(type_idx) };

                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                for typ in func_ty.params.valtypes.iter().rev() {
                    stack.assert_pop_val_type(*typ)?;
                }

                for typ in func_ty.returns.valtypes.iter() {
                    stack.push_valtype(*typ);
                }
            }
            // unreachable: [t1*] -> [t2*]
            UNREACHABLE => {
                stack.make_unspecified()?;
            }
            DROP => {
                stack.drop_val()?;
            }
            SELECT => {
                stack.validate_polymorphic_select()?;
            }
            SELECT_T => {
                let type_vec = wasm.read_vec(ValType::read)?;
                if type_vec.len() != 1 {
                    return Err(ValidationError::InvalidSelectTypeVectorLength(
                        type_vec.len(),
                    ));
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(type_vec[0])?;
                stack.assert_pop_val_type(type_vec[0])?;
                stack.push_valtype(type_vec[0]);
            }
            // local.get: [] -> [t]
            LOCAL_GET => {
                let local_idx = LocalIdx::read_and_validate(wasm, locals)?;
                let local_ty = locals
                    .get(local_idx.into_inner().into_usize())
                    .expect("the local index to be valid as this was just checked");
                stack.push_valtype(*local_ty);
            }
            // local.set [t] -> []
            LOCAL_SET => {
                let local_idx = LocalIdx::read_and_validate(wasm, locals)?;
                let local_ty = locals
                    .get(local_idx.into_inner().into_usize())
                    .expect("the local index to be valid as this was just checked");
                stack.assert_pop_val_type(*local_ty)?;
            }
            // local.set [t] -> [t]
            LOCAL_TEE => {
                let local_idx = LocalIdx::read_and_validate(wasm, locals)?;
                let local_ty = locals
                    .get(local_idx.into_inner().into_usize())
                    .expect("the local index to be valid as this was just checked");
                stack.assert_val_types_on_top(&[*local_ty], true)?;
            }
            // global.get [] -> [t]
            GLOBAL_GET => {
                let global_idx = GlobalIdx::read_and_validate(wasm, c_globals)?;
                // SAFETY: We just validated that this is a valid `TypeIdx` in
                // this vector.
                let global = unsafe { c_globals.get(global_idx) };

                stack.push_valtype(global.ty.ty);
                trace!(
                    "Instruction: global.get '{}' [] -> [{:?}]",
                    global_idx,
                    // global,
                    global.ty.ty
                );
            }
            // global.set [t] -> []
            GLOBAL_SET => {
                let global_idx = GlobalIdx::read_and_validate(wasm, c_globals)?;
                // SAFETY: We just validated that this is a valid `TypeIdx` in
                // this vector.
                let global = unsafe { c_globals.get(global_idx) };

                if !global.ty.is_mut {
                    return Err(ValidationError::MutationOfConstGlobal);
                }

                stack.assert_pop_val_type(global.ty.ty)?;
            }
            TABLE_GET => {
                let table_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                // SAFETY: We just validated that this is a valid `TableIdx` in
                // this `IdxVec<TableIdx, TableType>`.
                let table = unsafe { c_tables.get(table_idx) };
                let t = table.et;

                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::RefType(t));
            }
            TABLE_SET => {
                let table_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                // SAFETY: We just validated that this is a valid `TableIdx` in
                // this `IdxVec<TableIdx, TableType>`.
                let table = unsafe { c_tables.get(table_idx) };
                let t = table.et;

                stack.assert_pop_ref_type(Some(t))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I32_LOAD => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_LOAD => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 3 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 3,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            F32_LOAD => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::F32));
            }
            F64_LOAD => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 3 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 3,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::F64));
            }
            I32_LOAD8_S => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 0 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 0,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I32_LOAD8_U => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 0 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 0,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I32_LOAD16_S => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 1 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 1,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I32_LOAD16_U => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 1 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 1,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_LOAD8_S => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 0 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 0,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_LOAD8_U => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 0 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 0,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_LOAD16_S => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 1 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 1,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_LOAD16_U => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 1 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 1,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_LOAD32_S => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_LOAD32_U => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I32_STORE => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I64_STORE => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 3 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 3,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            F32_STORE => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            F64_STORE => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 3 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 3,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I32_STORE8 => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 0 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 0,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I32_STORE16 => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 1 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 1,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I64_STORE8 => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 0 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 0,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I64_STORE16 => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 1 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 1,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            I64_STORE32 => {
                let _mem_idx = MemIdx::validate(0, c_mems)?;
                let memarg = MemArg::read(wasm)?;
                if memarg.align > 2 {
                    return Err(ValidationError::ErroneousAlignment {
                        alignment: memarg.align,
                        minimum_required_alignment: 2,
                    });
                }
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
            }
            MEMORY_SIZE => {
                // Note: This zero byte is reserved for the multiple
                // memories proposal.
                let zero = wasm.read_u8()?;
                if zero != 0 {
                    return Err(ValidationError::UnsupportedMultipleMemoriesProposal);
                }
                let _mem_idx = MemIdx::validate(0, c_mems)?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            MEMORY_GROW => {
                // Note: This zero byte is reserved for the multiple
                // memories proposal.
                let zero = wasm.read_u8()?;
                if zero != 0 {
                    return Err(ValidationError::UnsupportedMultipleMemoriesProposal);
                }
                let _mem_idx = MemIdx::validate(0, c_mems)?;

                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            // i32.const: [] -> [i32]
            I32_CONST => {
                let _num = wasm.read_var_i32()?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_CONST => {
                let _num = wasm.read_var_i64()?;
                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            F32_CONST => {
                let _num = wasm.read_f32()?;
                stack.push_valtype(ValType::NumType(NumType::F32));
            }
            F64_CONST => {
                let _num = wasm.read_f64()?;
                stack.push_valtype(ValType::NumType(NumType::F64));
            }
            I32_EQZ => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I32_EQ | I32_NE | I32_LT_S | I32_LT_U | I32_GT_S | I32_GT_U | I32_LE_S | I32_LE_U
            | I32_GE_S | I32_GE_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_EQZ => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_EQ | I64_NE | I64_LT_S | I64_LT_U | I64_GT_S | I64_GT_U | I64_LE_S | I64_LE_U
            | I64_GE_S | I64_GE_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            F32_EQ | F32_NE | F32_LT | F32_GT | F32_LE | F32_GE => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            F64_EQ | F64_NE | F64_LT | F64_GT | F64_LE | F64_GE => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            F32_ABS | F32_NEG | F32_CEIL | F32_FLOOR | F32_TRUNC | F32_NEAREST | F32_SQRT => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;

                stack.push_valtype(ValType::NumType(NumType::F32));
            }
            F32_ADD | F32_SUB | F32_MUL | F32_DIV | F32_MIN | F32_MAX | F32_COPYSIGN => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;

                stack.push_valtype(ValType::NumType(NumType::F32));
            }
            F64_ABS | F64_NEG | F64_CEIL | F64_FLOOR | F64_TRUNC | F64_NEAREST | F64_SQRT => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;

                stack.push_valtype(ValType::NumType(NumType::F64));
            }
            F64_ADD | F64_SUB | F64_MUL | F64_DIV | F64_MIN | F64_MAX | F64_COPYSIGN => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;

                stack.push_valtype(ValType::NumType(NumType::F64));
            }
            I32_ADD | I32_SUB | I32_MUL | I32_DIV_S | I32_DIV_U | I32_REM_S => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            // i32.clz: [i32] -> [i32]
            I32_CLZ | I32_CTZ | I32_POPCNT => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I32_REM_U | I32_AND | I32_OR | I32_XOR | I32_SHL | I32_SHR_S | I32_SHR_U | I32_ROTL
            | I32_ROTR => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_CLZ | I64_CTZ | I64_POPCNT => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }

            I64_ADD | I64_SUB | I64_MUL | I64_DIV_S | I64_DIV_U | I64_REM_S | I64_REM_U
            | I64_AND | I64_OR | I64_XOR | I64_SHL | I64_SHR_S | I64_SHR_U | I64_ROTL
            | I64_ROTR => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }

            I32_WRAP_I64 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }

            I32_TRUNC_F32_S | I32_TRUNC_F32_U | I32_REINTERPRET_F32 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }

            I32_TRUNC_F64_S | I32_TRUNC_F64_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }

            I64_EXTEND_I32_S | I64_EXTEND_I32_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }

            I64_TRUNC_F32_S | I64_TRUNC_F32_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }

            I64_TRUNC_F64_S | I64_TRUNC_F64_U | I64_REINTERPRET_F64 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }

            F32_CONVERT_I32_S | F32_CONVERT_I32_U | F32_REINTERPRET_I32 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::F32));
            }

            F32_CONVERT_I64_S | F32_CONVERT_I64_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::F32));
            }

            F32_DEMOTE_F64 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;

                stack.push_valtype(ValType::NumType(NumType::F32));
            }

            F64_CONVERT_I32_S | F64_CONVERT_I32_U => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::F64));
            }

            F64_CONVERT_I64_S | F64_CONVERT_I64_U | F64_REINTERPRET_I64 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::F64));
            }

            F64_PROMOTE_F32 => {
                stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;

                stack.push_valtype(ValType::NumType(NumType::F64));
            }

            REF_NULL => {
                let reftype = RefType::read(wasm)?;
                // at validation-time we don't really care if it's null or not
                stack.push_valtype(ValType::RefType(reftype));
            }

            REF_IS_NULL => {
                stack.assert_pop_ref_type(None)?;
                stack.push_valtype(ValType::NumType(NumType::I32));
            }

            REF_FUNC => {
                let func_idx = FuncIdx::read_and_validate(wasm, c_funcs)?;

                // check whether func_idx is in C.refs
                // https://webassembly.github.io/spec/core/valid/conventions.html#context
                if !validation_context_refs.contains(&func_idx) {
                    return Err(ValidationError::ReferencingAnUnreferencedFunction(func_idx));
                }

                stack.push_valtype(ValType::RefType(RefType::FuncRef));
            }

            FC_EXTENSIONS => {
                let Ok(second_instr) = wasm.read_var_u32() else {
                    // TODO only do this if EOF
                    return Err(ValidationError::ExprMissingEnd);
                };

                #[cfg(feature = "log")]
                crate::core::utils::print_beautiful_fc_extension(second_instr, wasm.pc);

                #[cfg(feature = "log")]
                trace!(
                    "Read instruction byte {second_instr} at wasm_binary[{}]",
                    wasm.pc
                );

                use crate::core::reader::types::opcode::fc_extensions::*;
                match second_instr {
                    I32_TRUNC_SAT_F32_S => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I32_TRUNC_SAT_F32_U => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I32_TRUNC_SAT_F64_S => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I32_TRUNC_SAT_F64_U => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I64_TRUNC_SAT_F32_S => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                        stack.push_valtype(ValType::NumType(NumType::I64));
                    }
                    I64_TRUNC_SAT_F32_U => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                        stack.push_valtype(ValType::NumType(NumType::I64));
                    }
                    I64_TRUNC_SAT_F64_S => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                        stack.push_valtype(ValType::NumType(NumType::I64));
                    }
                    I64_TRUNC_SAT_F64_U => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                        stack.push_valtype(ValType::NumType(NumType::I64));
                    }
                    MEMORY_INIT => {
                        let data_idx = DataIdx::read_and_validate(
                            wasm,
                            data_count.ok_or(ValidationError::MissingDataCountSection)?,
                        );
                        // Note: This zero byte is reserved for the multiple
                        // memories proposal.
                        let zero = wasm.read_u8()?;
                        if zero != 0 {
                            return Err(ValidationError::UnsupportedMultipleMemoriesProposal);
                        }
                        if c_mems.len() == 0 {
                            return Err(ValidationError::InvalidMemIdx(0));
                        }
                        // Validate data index after memory index
                        let _data_idx = data_idx?;

                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    DATA_DROP => {
                        let _data_idx = DataIdx::read_and_validate(
                            wasm,
                            data_count.ok_or(ValidationError::MissingDataCountSection)?,
                        )?;
                    }
                    MEMORY_COPY => {
                        // Note: These zero bytes are reserved for the multiple
                        // memories proposal.
                        let zeros = (wasm.read_u8()?, wasm.read_u8()?);
                        if zeros != (0, 0) {
                            return Err(ValidationError::UnsupportedMultipleMemoriesProposal);
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;

                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    MEMORY_FILL => {
                        // Note: This zero byte is reserved for the multiple
                        // memories proposal.
                        let zero = wasm.read_u8()?;
                        if zero != 0 {
                            return Err(ValidationError::UnsupportedMultipleMemoriesProposal);
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;

                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    TABLE_INIT => {
                        // Validation requires us to validate the table index
                        // before the element index -- even though these are
                        // encoded the other way around.
                        let elem_idx = ElemIdx::read_and_validate(wasm, c_elems);
                        let table_idx = TableIdx::read_and_validate(wasm, c_tables);
                        if let Err(invalid_table_idx @ ValidationError::InvalidTableIdx(_)) =
                            table_idx
                        {
                            return Err(invalid_table_idx);
                        }
                        let elem_idx = elem_idx?;
                        let table_idx = table_idx?;

                        // SAFETY: We just validated that this is a valid
                        // `TableIdx` in this `IdxVec<TableIdx, TableType>`.
                        let table1 = unsafe { c_tables.get(table_idx) };
                        let table_type = table1.et;

                        // SAFETY: We just validated that this is a valid
                        // `ElemIdx` in this `IdxVec`.
                        let element = unsafe { c_elems.get(elem_idx) };
                        let element_type = element.to_ref_type();

                        if table_type != element_type {
                            return Err(ValidationError::MismatchedRefTypesDuringTableInit {
                                table_ty: table_type,
                                elem_ty: element_type,
                            });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        // INFO: wasmtime checks for this value to be an index in the tables array, interesting
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    ELEM_DROP => {
                        let _elem_idx = ElemIdx::read_and_validate(wasm, c_elems)?;
                    }
                    TABLE_COPY => {
                        let table_x_idx = TableIdx::read_and_validate(wasm, c_tables)?;
                        let table_y_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                        // SAFETY: We just validated that this is a valid
                        // `TableIdx` in this `IdxVec<TableIdx, TableType>`.
                        let table1 = unsafe { c_tables.get(table_x_idx) };
                        // SAFETY: We just validated that this is a valid
                        // `TableIdx` in this `IdxVec<TableIdx, TableType>`.
                        let table2 = unsafe { c_tables.get(table_y_idx) };

                        let t1 = table1.et;
                        let t2 = table2.et;

                        if t1 != t2 {
                            return Err(ValidationError::MismatchedRefTypesDuringTableCopy {
                                source_table_ty: t2,
                                destination_table_ty: t1,
                            });
                        }

                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    TABLE_GROW => {
                        let table_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                        // SAFETY: We just validated that this is a valid
                        // `TableIdx` in this `IdxVec<TableIdx, TableType>`.
                        let table = unsafe { c_tables.get(table_idx) };
                        let t = table.et;

                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_ref_type(Some(t))?;

                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    TABLE_SIZE => {
                        let _table_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    TABLE_FILL => {
                        let table_idx = TableIdx::read_and_validate(wasm, c_tables)?;

                        // SAFETY: We just validated that this is a valid
                        // `TableIdx` in this `IdxVec<TableIdx, TableType>`.
                        let table = unsafe { c_tables.get(table_idx) };
                        let t = table.et;

                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_ref_type(Some(t))?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    _ => {
                        return Err(ValidationError::InvalidMultiByteInstr(
                            first_instr_byte,
                            second_instr,
                        ))
                    }
                }
            }

            I32_EXTEND8_S => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I32_EXTEND16_S => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;

                stack.push_valtype(ValType::NumType(NumType::I32));
            }
            I64_EXTEND8_S => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_EXTEND16_S => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }
            I64_EXTEND32_S => {
                stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;

                stack.push_valtype(ValType::NumType(NumType::I64));
            }

            FD_EXTENSIONS => {
                let Ok(second_instr) = wasm.read_var_u32() else {
                    // TODO only do this if EOF
                    return Err(ValidationError::ExprMissingEnd);
                };

                #[cfg(feature = "log")]
                crate::core::utils::print_beautiful_fd_extension(second_instr, wasm.pc);

                use crate::core::reader::types::opcode::fd_extensions::*;

                match second_instr {
                    V128_LOAD => {
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 4 {
                            return Err(ValidationError::ErroneousAlignment {
                                alignment: memarg.align,
                                minimum_required_alignment: 4,
                            });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_STORE => {
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 4 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 4 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }

                    // v128.loadNxM_sx
                    V128_LOAD8X8_S | V128_LOAD8X8_U
                    | V128_LOAD16X4_S | V128_LOAD16X4_U
                    | V128_LOAD32X2_S | V128_LOAD32X2_U
                    => {
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 3 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 3 });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    },

                    // v128.loadN_splat + v128.loadN_zero
                    V128_LOAD8_SPLAT => {
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 0 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 0 });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_LOAD16_SPLAT => {
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 1 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 1 });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_LOAD32_SPLAT | V128_LOAD32_ZERO => {
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 2 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 2 });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_LOAD64_SPLAT | V128_LOAD64_ZERO => {
                    let _mem_idx = MemIdx::validate(0, c_mems)?;
                        let memarg = MemArg::read(wasm)?;
                        if memarg.align > 3 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 3 });
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // v128.loadN_lane
                    V128_LOAD8_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 16 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 0 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 0 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_LOAD16_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 8 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 1 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 1 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_LOAD32_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 4 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 2 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 2 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    V128_LOAD64_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 2 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 3 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 3 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // v128.storeN_lane
                    V128_STORE8_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 16 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 0 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 0 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    V128_STORE16_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 8 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 1 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 1 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    V128_STORE32_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 4 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 2 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 2 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }
                    V128_STORE64_LANE => {
                        let memarg = MemArg::read(wasm)?;
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 2 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        let _mem_idx = MemIdx::validate(0, c_mems)?;
                        if memarg.align > 3 {
                            return Err(ValidationError::ErroneousAlignment { alignment: memarg.align, minimum_required_alignment: 3 });
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                    }

                    V128_CONST => {
                        for _ in 0..16 {
                            let _data = wasm.read_u8()?;
                        }
                        stack.push_valtype(ValType::VecType);
                    }

                    // vvunop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vvunop>
                    V128_NOT => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // vvbinop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vvbinop>
                    V128_AND | V128_ANDNOT | V128_OR | V128_XOR => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // vvternop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vvternop>
                    V128_BITSELECT => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // vvtestop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vvtestop>
                    V128_ANY_TRUE => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I8X16_SWIZZLE => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }
                    I8X16_SHUFFLE => {
                        for _ in 0..16 {
                            let lane_idx = wasm.read_u8()?;
                            if lane_idx >= 32 {
                                return Err(ValidationError::InvalidLaneIdx(lane_idx));
                            }
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // shape.splat
                    I8X16_SPLAT | I16X8_SPLAT | I32X4_SPLAT => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    I64X2_SPLAT => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    F32X4_SPLAT => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                        stack.push_valtype(ValType::VecType);
                    }
                    F64X2_SPLAT => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // shape.extract_lane
                    I8X16_EXTRACT_LANE_S | I8X16_EXTRACT_LANE_U => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 16 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I16X8_EXTRACT_LANE_S | I16X8_EXTRACT_LANE_U => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 8 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I32X4_EXTRACT_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 4 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }
                    I64X2_EXTRACT_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 2 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I64));
                    }
                    F32X4_EXTRACT_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 4 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::F32));
                    }
                    F64X2_EXTRACT_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 2 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::F64));
                    }

                    // shape.replace_lane
                    I8X16_REPLACE_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 16 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }
                    I16X8_REPLACE_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 8 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }
                    I32X4_REPLACE_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 4 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }
                    I64X2_REPLACE_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 2 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::I64))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }
                    F32X4_REPLACE_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 4 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::F32))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }
                    F64X2_REPLACE_LANE => {
                        let lane_idx = wasm.read_u8()?;
                        if lane_idx >= 2 {
                            return Err(ValidationError::InvalidLaneIdx(lane_idx));
                        }
                        stack.assert_pop_val_type(ValType::NumType(NumType::F64))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // Group vunop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vunop>
                    // viunop
                    I8X16_ABS | I16X8_ABS | I32X4_ABS | I64X2_ABS
                    | I8X16_NEG | I16X8_NEG | I32X4_NEG | I64X2_NEG
                    // vfunop
                    | F32X4_ABS | F64X2_ABS
                    | F32X4_NEG | F64X2_NEG
                    | F32X4_SQRT | F64X2_SQRT
                    | F32X4_CEIL | F64X2_CEIL
                    | F32X4_FLOOR | F64X2_FLOOR
                    | F32X4_TRUNC | F64X2_TRUNC
                    | F32X4_NEAREST | F64X2_NEAREST
                    // others
                    | I8X16_POPCNT
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // Group vbinop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vbinop>
                    // vibinop
                    I8X16_ADD | I16X8_ADD | I32X4_ADD | I64X2_ADD
                    | I8X16_SUB | I16X8_SUB | I32X4_SUB | I64X2_SUB
                    // vfbinop
                    | F32X4_ADD | F64X2_ADD
                    | F32X4_SUB | F64X2_SUB
                    | F32X4_MUL | F64X2_MUL
                    | F32X4_DIV | F64X2_DIV
                    | F32X4_MIN | F64X2_MIN
                    | F32X4_MAX | F64X2_MAX
                    | F32X4_PMIN | F64X2_PMIN
                    | F32X4_PMAX | F64X2_PMAX
                    // viminmaxop
                    | I8X16_MIN_S | I16X8_MIN_S | I32X4_MIN_S
                    | I8X16_MIN_U | I16X8_MIN_U | I32X4_MIN_U
                    | I8X16_MAX_S | I16X8_MAX_S | I32X4_MAX_S
                    | I8X16_MAX_U | I16X8_MAX_U | I32X4_MAX_U
                    // visatbinop
                    | I8X16_ADD_SAT_S | I16X8_ADD_SAT_S
                    | I8X16_ADD_SAT_U | I16X8_ADD_SAT_U
                    | I8X16_SUB_SAT_S | I16X8_SUB_SAT_S
                    | I8X16_SUB_SAT_U | I16X8_SUB_SAT_U
                    // others
                    | I16X8_MUL | I32X4_MUL | I64X2_MUL
                    | I8X16_AVGR_U | I16X8_AVGR_U
                    | I16X8_Q15MULRSAT_S
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // Group vrelop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vrelop>
                    // virelop
                    I8X16_EQ | I16X8_EQ | I32X4_EQ | I64X2_EQ
                    | I8X16_NE | I16X8_NE | I32X4_NE | I64X2_NE
                    | I8X16_LT_S | I16X8_LT_S | I32X4_LT_S | I64X2_LT_S
                    | I8X16_LT_U | I16X8_LT_U | I32X4_LT_U | I8X16_GT_S
                    | I16X8_GT_S | I32X4_GT_S | I64X2_GT_S
                    | I8X16_GT_U | I16X8_GT_U | I32X4_GT_U
                    | I8X16_LE_S | I16X8_LE_S | I32X4_LE_S | I64X2_LE_S
                    | I8X16_LE_U | I16X8_LE_U | I32X4_LE_U
                    | I8X16_GE_S | I16X8_GE_S | I32X4_GE_S | I64X2_GE_S
                    | I8X16_GE_U | I16X8_GE_U | I32X4_GE_U
                    // vfrelop
                    | F32X4_EQ | F64X2_EQ
                    | F32X4_NE | F64X2_NE
                    | F32X4_LT | F64X2_LT
                    | F32X4_GT | F64X2_GT
                    | F32X4_LE | F64X2_LE
                    | F32X4_GE | F64X2_GE
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // Group vishiftop
                    I8X16_SHL | I16X8_SHL | I32X4_SHL | I64X2_SHL
                    | I8X16_SHR_S | I8X16_SHR_U | I16X8_SHR_S | I16X8_SHR_U | I32X4_SHR_S | I32X4_SHR_U | I64X2_SHR_S | I64X2_SHR_U
                     => {
                        stack.assert_pop_val_type(ValType::NumType(NumType::I32))?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // Group vtestop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vtestop>
                    // vitestop
                    I8X16_ALL_TRUE | I16X8_ALL_TRUE | I32X4_ALL_TRUE | I64X2_ALL_TRUE
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }

                    // Group vcvtop <https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-vcvtop>
                    I16X8_EXTEND_HIGH_I8X16_S | I16X8_EXTEND_HIGH_I8X16_U | I16X8_EXTEND_LOW_I8X16_S | I16X8_EXTEND_LOW_I8X16_U
                    | I32X4_EXTEND_HIGH_I16X8_S | I32X4_EXTEND_HIGH_I16X8_U | I32X4_EXTEND_LOW_I16X8_S | I32X4_EXTEND_LOW_I16X8_U
                    | I64X2_EXTEND_HIGH_I32X4_S | I64X2_EXTEND_HIGH_I32X4_U | I64X2_EXTEND_LOW_I32X4_S | I64X2_EXTEND_LOW_I32X4_U
                    | I32X4_TRUNC_SAT_F32X4_S | I32X4_TRUNC_SAT_F32X4_U | I32X4_TRUNC_SAT_F64X2_S_ZERO | I32X4_TRUNC_SAT_F64X2_U_ZERO
                    | F32X4_CONVERT_I32X4_S | F32X4_CONVERT_I32X4_U | F64X2_CONVERT_LOW_I32X4_S | F64X2_CONVERT_LOW_I32X4_U
                    | F32X4_DEMOTE_F64X2_ZERO
                    | F64X2_PROMOTE_LOW_F32X4
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // ishape.narrow_ishape_sx
                    | I8X16_NARROW_I16X8_S | I8X16_NARROW_I16X8_U
                    | I16X8_NARROW_I32X4_S | I16X8_NARROW_I32X4_U
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // ishape.bitmask
                    I8X16_BITMASK | I16X8_BITMASK | I32X4_BITMASK | I64X2_BITMASK
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::NumType(NumType::I32));
                    }

                    // ishape.dot_ishape_s
                    I32X4_DOT_I16X8_S => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // ishape.extmul_half_ishape_sx
                    I16X8_EXTMUL_HIGH_I8X16_S | I16X8_EXTMUL_HIGH_I8X16_U | I16X8_EXTMUL_LOW_I8X16_S | I16X8_EXTMUL_LOW_I8X16_U
                    | I32X4_EXTMUL_HIGH_I16X8_S | I32X4_EXTMUL_HIGH_I16X8_U | I32X4_EXTMUL_LOW_I16X8_S | I32X4_EXTMUL_LOW_I16X8_U
                    | I64X2_EXTMUL_HIGH_I32X4_S | I64X2_EXTMUL_HIGH_I32X4_U | I64X2_EXTMUL_LOW_I32X4_S | I64X2_EXTMUL_LOW_I32X4_U
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // ishape.extadd_pairwise_ishape_sx
                    I16X8_EXTADD_PAIRWISE_I8X16_S | I16X8_EXTADD_PAIRWISE_I8X16_U
                    | I32X4_EXTADD_PAIRWISE_I16X8_S | I32X4_EXTADD_PAIRWISE_I16X8_U
                    => {
                        stack.assert_pop_val_type(ValType::VecType)?;
                        stack.push_valtype(ValType::VecType);
                    }

                    // Unimplemented or invalid instructions
                    F32X4_RELAXED_MADD | F32X4_RELAXED_MAX | F32X4_RELAXED_MIN | F32X4_RELAXED_NMADD
                    | F64X2_RELAXED_MADD | F64X2_RELAXED_MAX | F64X2_RELAXED_MIN | F64X2_RELAXED_NMADD
                    | I8X16_RELAXED_LANESELECT | I16X8_RELAXED_LANESELECT | I32X4_RELAXED_LANESELECT | I64X2_RELAXED_LANESELECT
                    | I32X4_RELAXED_TRUNC_F32X4_S | I32X4_RELAXED_TRUNC_F32X4_U
                    | I32X4_RELAXED_TRUNC_F64X2_S_ZERO | I32X4_RELAXED_TRUNC_F64X2_U_ZERO
                    | I8X16_RELAXED_SWIZZLE
                    | 154 | 187 | 194 | 256.. => return Err(ValidationError::InvalidMultiByteInstr(first_instr_byte, second_instr)),
                }
            }

            // Unimplemented or invalid instructions
            0x06..=0x0A
            | 0x12..=0x19
            | 0x1C..=0x1F
            | 0x25..=0x27
            | 0xC0..=0xFA
            | 0xFB
            | 0xFE
            | 0xFF => {
                return Err(ValidationError::InvalidInstr(first_instr_byte));
            }
        }
    }
}