ladybird/Libraries/LibWasm/AbstractMachine/Validator.cpp

/*
 * Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/GenericShorthands.h>
#include <AK/HashTable.h>
#include <AK/SourceLocation.h>
#include <AK/TemporaryChange.h>
#include <AK/Try.h>
#include <LibWasm/AbstractMachine/Validator.h>
#include <LibWasm/Printer/Printer.h>

namespace Wasm {

ErrorOr<void, ValidationError> Validator::validate(Module& module)
{
    // Pre-emptively make invalid. The module will be set to `Valid` at the end
    // of validation.
    module.set_validation_status(Module::ValidationStatus::Invalid, {});

    // Note: The spec performs this after populating the context, but there's no real reason to do so,
    //       as this has no dependency.
    HashTable<StringView> seen_export_names;
    for (auto& export_ : module.export_section().entries())
        if (seen_export_names.try_set(export_.name()).release_value_but_fixme_should_propagate_errors() != AK::HashSetResult::InsertedNewEntry)
            return Errors::duplicate_export_name(export_.name());

    m_context = {};

    m_context.types.extend(module.type_section().types());
    m_context.data_count = module.data_count_section().count();

    // https://webassembly.github.io/spec/core/valid/modules.html#types
    // Intern the type section's recursive groups as defined types ("the defined type sequence
    // dt* is of the form roll*_x(rectype)") before anything else can refer to them; the rest of
    // the sub type validation rule runs in validate(TypeSection const&) below.
    {
        auto canonical_types = TRY(canonicalize_module_types(module.type_section()));
        m_context.canonical_types.extend(canonical_types);
        module.set_canonical_types(move(canonical_types));
    }
    TRY(validate(module.type_section()));

    for (auto& import_ : module.import_section().imports()) {
        TRY(import_.description().visit(
            [&](TypeIndex const& index) -> ErrorOr<void, ValidationError> {
                if (m_context.types.size() > index.value()) {
                    m_context.types[index.value()].description().visit(
                        [&](FunctionType const& func) {
                            m_context.functions.append(func);
                            m_context.function_type_indices.append(index);
                            m_context.imported_function_count++;
                        },
                        [&](StructType const& struct_) {
                            m_context.structs.append(struct_);
                        },
                        [&](ArrayType const& array) {
                            m_context.arrays.append(array);
                        });
                } else {
                    return Errors::invalid("TypeIndex"sv);
                }
                return {};
            },
            [&](FunctionType const& type) -> ErrorOr<void, ValidationError> {
                m_context.functions.append(type);
                m_context.function_type_indices.append({});
                m_context.imported_function_count++;
                return {};
            },
            [&](TableType const& type) -> ErrorOr<void, ValidationError> {
                m_context.tables.append(type);
                return {};
            },
            [&](MemoryType const& type) -> ErrorOr<void, ValidationError> {
                m_context.memories.append(type);
                return {};
            },
            [&](GlobalType const& type) -> ErrorOr<void, ValidationError> {
                m_globals_without_internal_globals.append(type);
                m_context.globals.append(type);
                return {};
            },
            [&](TagType const&) -> ErrorOr<void, ValidationError> {
                m_context.tags.append(import_.description().get<TagType>());
                return {};
            }));
    }

    if (module.code_section().functions().size() != module.function_section().types().size())
        return Errors::invalid("FunctionSection"sv);

    m_context.functions.ensure_capacity(module.function_section().types().size() + m_context.functions.size());
    m_context.function_type_indices.ensure_capacity(module.function_section().types().size() + m_context.function_type_indices.size());
    for (auto& index : module.function_section().types()) {
        if (m_context.types.size() <= index.value() || !m_context.types[index.value()].is_function())
            return Errors::invalid("TypeIndex"sv);
        m_context.functions.append(m_context.types[index.value()].function());
        m_context.function_type_indices.append(index);
    }

    m_context.tables.ensure_capacity(m_context.tables.size() + module.table_section().tables().size());
    for (auto& table : module.table_section().tables())
        m_context.tables.append(table.type());

    m_context.memories.ensure_capacity(m_context.memories.size() + module.memory_section().memories().size());
    for (auto& memory : module.memory_section().memories())
        m_context.memories.append(memory.type());

    m_context.globals.ensure_capacity(m_context.globals.size() + module.global_section().entries().size());
    for (auto& global : module.global_section().entries())
        m_context.globals.append(global.type());

    m_context.elements.ensure_capacity(module.element_section().segments().size());
    for (auto& segment : module.element_section().segments())
        m_context.elements.append(segment.type);

    m_context.datas.resize(module.data_section().data().size());

    m_context.tags.ensure_capacity(m_context.tags.size() + module.tag_section().tags().size());
    for (auto& tag : module.tag_section().tags())
        m_context.tags.append(TagType(tag.type(), tag.flags()));

    // We need to build the set of declared functions to check that `ref.func` uses a specific set of predetermined functions, found in:
    // - Element initializer expressions
    // - Global initializer expressions
    // - Exports
    auto scan_expression_for_function_indices = [&](auto& expression) {
        for (auto& instruction : expression.instructions()) {
            if (instruction.opcode() == Instructions::ref_func) {
                auto index = instruction.arguments().template get<FunctionIndex>();
                m_context.references->tree.insert(index.value(), index);
            }
        }
    };
    for (auto& export_ : module.export_section().entries()) {
        if (!export_.description().has<FunctionIndex>())
            continue;
        auto index = export_.description().get<FunctionIndex>();
        m_context.references->tree.insert(index.value(), index);
    }
    for (auto& segment : module.element_section().segments()) {
        for (auto& expression : segment.init)
            scan_expression_for_function_indices(expression);
    }
    for (auto& segment : module.global_section().entries())
        scan_expression_for_function_indices(segment.expression());
    for (auto& table : module.table_section().tables())
        scan_expression_for_function_indices(table.initializer());

    TRY(validate(module.import_section()));
    TRY(validate(module.export_section()));
    TRY(validate(module.start_section()));
    TRY(validate(module.data_section()));
    TRY(validate(module.element_section()));
    TRY(validate(module.global_section()));
    TRY(validate(module.memory_section()));
    TRY(validate(module.table_section()));
    TRY(validate(module.code_section()));
    TRY(validate(module.tag_section()));

    for (auto& entry : module.code_section().functions())
        module.set_minimum_call_record_allocation_size(max(entry.func().body().compiled_instructions.max_call_rec_size, module.minimum_call_record_allocation_size()));

    module.set_validation_status(Module::ValidationStatus::Valid, {});
    return {};
}

void compile_module_to_native(Module& module)
{
    auto cache_config = module.take_cranelift_cache_config();
    auto stats = module.take_compile_stats();

    bool installing = false;
    bool capturing = false;

    if (cache_config.has_value()) {
        auto hash = ReadonlyBytes { cache_config->wasm_hash.data(), 32 };
        if (!cache_config->existing_blob.is_empty())
            installing = try_install_cranelift_cache_blob(hash, cache_config->existing_blob.bytes());
        if (!installing && cache_config->on_compiled) {
            begin_cranelift_cache_capture();
            capturing = true;
        }
    }

    ScopeGuard cleanup = [&] {
        auto cranelift_start = MonotonicTime::now();
        flush_cranelift_batch();
        auto cranelift_duration = MonotonicTime::now() - cranelift_start;

        if (installing)
            abort_cranelift_cache_install();

        size_t produced_blob_size = 0;
        if (capturing) {
            auto hash = ReadonlyBytes { cache_config->wasm_hash.data(), 32 };
            if (auto blob = serialize_cranelift_cache_blob(hash); blob.has_value() && cache_config->on_compiled) {
                produced_blob_size = blob->size();
                cache_config->on_compiled(blob.release_value());
            } else {
                abort_cranelift_cache_capture();
            }
        }

        if (stats.has_value()) {
            stats->cranelift_time = cranelift_duration;
            stats->cranelift_blob_size_bytes = produced_blob_size;
            stats->cache_hit = installing;
            size_t count = 0;
            size_t tier_up_functions = 0;
            size_t tier_up_checkpoints = 0;
            for (auto& entry : module.code_section().functions()) {
                auto const& ci = entry.func().body().compiled_instructions;
                if (ci.cranelift_compiled)
                    ++count;
                if (ci.has_tier_up_checkpoints) {
                    ++tier_up_functions;
                    for (auto const& dispatch : ci.dispatches) {
                        if (dispatch.instruction->opcode() == Instructions::synthetic_tier_up)
                            ++tier_up_checkpoints;
                    }
                }
            }
            stats->function_count = count;
            stats->tier_up_function_count = tier_up_functions;
            stats->tier_up_checkpoint_count = tier_up_checkpoints;
            record_module_stats(stats.release_value());
        }

        set_cranelift_active_function_index(NumericLimits<u32>::max());
    };

    size_t imported_function_count = 0;
    for (auto& import_ : module.import_section().imports()) {
        import_.description().visit(
            [&](TypeIndex const& type_index) {
                auto& types = module.type_section().types();
                if (type_index.value() < types.size() && types[type_index.value()].is_function())
                    ++imported_function_count;
            },
            [&](FunctionType const&) { ++imported_function_count; },
            [&](auto const&) {});
    }

    size_t function_index = imported_function_count;
    for (auto& entry : module.code_section().functions()) {
        auto& compiled = entry.func().body().compiled_instructions;
        set_cranelift_active_function_index(static_cast<u32>(function_index++));
        if (compiled.cranelift_eligible)
            try_cranelift_compile(compiled, compiled.cranelift_result_arity);
    }
}

ErrorOr<void, ValidationError> ensure_cranelift_compiled(Module& module)
{
    if (!module.try_begin_cranelift_compilation()) {
        module.wait_for_cranelift_compilation();
        return {};
    }

    if (module.validation_status() == Module::ValidationStatus::Invalid) {
        module.finish_cranelift_compilation();
        return ValidationError { module.validation_error() };
    }

    compile_module_to_native(module);
    module.finish_cranelift_compilation();
    return {};
}

void start_cranelift_compilation(Module& module)
{
    (void)ensure_cranelift_compiled(module);
}

ErrorOr<void, ValidationError> Validator::validate(ImportSection const& section)
{
    for (auto& import_ : section.imports())
        TRY(import_.description().visit([&](auto& entry) { return validate(entry); }));
    return {};
}

ErrorOr<void, ValidationError> Validator::validate(ExportSection const& section)
{
    for (auto& export_ : section.entries())
        TRY(export_.description().visit([&](auto& entry) -> ErrorOr<void, ValidationError> { TRY(validate(entry)); return {}; }));
    return {};
}

ErrorOr<void, ValidationError> Validator::validate(StartSection const& section)
{
    if (!section.function().has_value())
        return {};
    TRY(validate(section.function()->index()));
    FunctionType const& type = m_context.functions[section.function()->index().value()];
    if (!type.parameters().is_empty() || !type.results().is_empty())
        return Errors::invalid("start function signature"sv);
    return {};
}

ErrorOr<void, ValidationError> Validator::validate(DataSection const& section)
{
    if (m_context.data_count.has_value() && section.data().size() != m_context.data_count)
        return Errors::invalid("data count does not match segment count"sv);
    for (auto& entry : section.data()) {
        TRY(entry.value().visit(
            [](DataSection::Data::Passive const&) { return ErrorOr<void, ValidationError> {}; },
            [&](DataSection::Data::Active const& active) -> ErrorOr<void, ValidationError> {
                auto memory = TRY(validate(active.index));
                auto const at = memory.limits().address_value_type();

                auto expression_result = TRY(validate(active.offset, { at }));

                if (!expression_result.is_constant)
                    return Errors::invalid("active data initializer"sv);

                if (expression_result.result_types.size() != 1 || !expression_result.result_types.first().is_of_kind(at.kind()))
                    return Errors::invalid("active data initializer type"sv, at, expression_result.result_types);

                return {};
            }));
    }

    return {};
}

ErrorOr<void, ValidationError> Validator::validate(ElementSection const& section)
{
    for (auto& segment : section.segments()) {
        // https://webassembly.github.io/spec/core/valid/modules.html#element-segments
        // - The reference type elemtype is valid.
        TRY(validate(segment.type));
        TRY(segment.mode.visit(
            [](ElementSection::Declarative const&) -> ErrorOr<void, ValidationError> { return {}; },
            [](ElementSection::Passive const&) -> ErrorOr<void, ValidationError> { return {}; },
            [&](ElementSection::Active const& active) -> ErrorOr<void, ValidationError> {
                // https://webassembly.github.io/spec/core/valid/modules.html#element-segments
                TRY(validate(active.index));
                auto table = m_context.tables[active.index.value()];
                if (!matches_reference_type(segment.type, table.element_type(), m_context.type_context()))
                    return Errors::invalid("active element reference type"sv);
                auto at = table.limits().address_value_type();
                auto expression_result = TRY(validate(active.expression, { at }));
                if (!expression_result.is_constant)
                    return Errors::invalid("active element initializer"sv);
                if (expression_result.result_types.size() != 1 || !expression_result.result_types.first().is_of_kind(at.kind()))
                    return Errors::invalid("active element initializer type"sv, at, expression_result.result_types);
                return {};
            }));

        for (auto& expression : segment.init) {
            if (expression.instructions().is_empty())
                continue;
            // https://webassembly.github.io/spec/core/valid/modules.html#element-segments
            auto result = TRY(validate(expression, { segment.type }));
            if (!result.is_constant)
                return Errors::invalid("element initializer"sv);
            if (result.result_types.size() != 1)
                return Errors::invalid("element initializer type"sv, segment.type, result.result_types);
        }
    }
    return {};
}

ErrorOr<void, ValidationError> Validator::validate(GlobalSection const& section)
{
    // https://webassembly.github.io/spec/core/valid/modules.html#modules
    auto section_validator = fork();
    section_validator.m_context.globals = m_globals_without_internal_globals;

    for (auto& entry : section.entries()) {
        auto& type = entry.type();
        TRY(section_validator.validate(type));
        auto expression_result = TRY(section_validator.validate(entry.expression(), { type.type() }));
        if (!expression_result.is_constant)
            return Errors::invalid("global variable initializer"sv);
        if (expression_result.result_types.size() != 1)
            return Errors::invalid("global variable initializer type"sv, ValueType(ValueType::I32), expression_result.result_types);
        section_validator.m_context.globals.append(type);
    }

    return {};
}

ErrorOr<void, ValidationError> Validator::validate(MemorySection const& section)
{
    for (auto& entry : section.memories())
        TRY(validate(entry.type()));
    return {};
}

// https://webassembly.github.io/spec/core/valid/modules.html#tables
ErrorOr<void, ValidationError> Validator::validate(TableSection const& section)
{
    auto section_validator = fork();
    section_validator.m_context.globals = m_globals_without_internal_globals;

    for (auto& entry : section.tables()) {
        TRY(section_validator.validate(entry.type()));
        auto expression_result = TRY(section_validator.validate(entry.initializer(), { entry.type().element_type() }));
        if (!expression_result.is_constant)
            return Errors::invalid("table initializer"sv);
        if (expression_result.result_types.size() != 1)
            return Errors::invalid("table initializer type"sv, entry.type().element_type(), expression_result.result_types);
    }
    return {};
}

ErrorOr<void, ValidationError> Validator::validate(CodeSection const& section)
{
    size_t index = m_context.imported_function_count;
    for (auto& entry : section.functions()) {
        auto function_index = index++;
        VERIFY(function_index <= NumericLimits<u32>::max());
        TRY(validate(FunctionIndex { static_cast<u32>(function_index) }));
        auto& function_type = m_context.functions[function_index];
        auto& function = entry.func();

        auto function_validator = fork();
        function_validator.m_context.locals = {};
        function_validator.m_context.locals.extend(function_type.parameters());
        function_validator.m_context.current_function_parameter_count = function_type.parameters().size();
        for (auto& local : function.locals()) {
            // https://webassembly.github.io/spec/core/valid/modules.html#functions
            // The locals' value types must be valid (in particular, type uses must exist).
            TRY(function_validator.validate(local.type()));
            for (size_t i = 0; i < local.n(); ++i)
                function_validator.m_context.locals.append(local.type());
        }

        // https://webassembly.github.io/spec/core/valid/modules.html#functions
        function_validator.m_local_initialized.clear_with_capacity();
        function_validator.m_local_init_log.clear_with_capacity();
        for (auto& parameter : function_type.parameters()) {
            (void)parameter;
            function_validator.m_local_initialized.append(true);
        }
        for (auto& local : function.locals()) {
            for (size_t i = 0; i < local.n(); ++i)
                function_validator.m_local_initialized.append(local.type().is_defaultable());
        }

        function_validator.push_frame(Frame { function_type, FrameKind::Function, (size_t)0 });

        auto results = TRY(function_validator.validate(function.body(), function_type.results()));
        if (results.result_types.size() != function_type.results().size())
            return Errors::invalid("function result"sv, function_type.results(), results.result_types);

        if (function.body().compiled_instructions.max_call_rec_size != 0) {
            size_t max_callee_locals = 0;
            for (auto& insn : function.body().instructions()) {
                if (!first_is_one_of(insn.opcode(), Instructions::call, Instructions::synthetic_call_with_record_0, Instructions::synthetic_call_with_record_1))
                    continue;
                auto callee_index = insn.arguments().template get<FunctionIndex>();
                if (callee_index.value() - m_context.imported_function_count < section.functions().size())
                    max_callee_locals = max(max_callee_locals, section.functions()[callee_index.value() - m_context.imported_function_count].func().total_local_count());
            }

            function.body().compiled_instructions.max_call_rec_size += max_callee_locals;
        }
    }

    return {};
}

ErrorOr<void, ValidationError> Validator::validate(TagSection const& section)
{
    for (auto& entry : section.tags())
        TRY(validate(entry));
    return {};
}

// https://webassembly.github.io/spec/core/valid/types.html#recursive-types
ErrorOr<void, ValidationError> Validator::validate(TypeSection const& section)
{
    for (size_t type_index = 0; type_index < section.types().size(); ++type_index)
        TRY(validate(section.types()[type_index], type_index));

    return {};
}

ErrorOr<void, ValidationError> Validator::validate(TableType const& type)
{
    TRY(validate(type.element_type()));
    Optional<u64> bound = type.limits().address_type() == AddressType::I64 ? Optional<u64> {} : (1ull << 32) - 1;
    return validate(type.limits(), bound);
}

ErrorOr<void, ValidationError> Validator::validate(MemoryType const& type)
{
    u64 bound = type.limits().address_type() == AddressType::I64 ? 1ull << 48 : 1ull << 16;
    return validate(type.limits(), bound);
}

ErrorOr<void, ValidationError> Validator::validate(Wasm::TagType const& tag_type)
{
    // The function type t1^n -> t2^m must be valid
    TRY(validate(tag_type.type()));
    auto& type = m_context.types[tag_type.type().value()];
    if (!type.is_function())
        return Errors::invalid("TagType"sv);

    auto& func = type.function();

    // The type sequence t2^m must be empty
    if (!func.results().is_empty())
        return Errors::invalid("TagType"sv);
    return {};
}

ErrorOr<void, ValidationError> Validator::validate(ValueType const& type)
{
    if (type.is_typeuse()) {
        TRY(validate(type.unsafe_typeindex()));
    }

    return {};
}

// https://webassembly.github.io/spec/core/valid/types.html#recursive-types
ErrorOr<void, ValidationError> Validator::validate(TypeSection::Type const& type, size_t this_type_index)
{
    // - The length of x* is less than or equal to 1.
    if (type.supertypes().size() > 1)
        return Errors::invalid("supertype count, only a single supertype is allowed"sv);

    // - For all x in x*:
    for (auto supertype_index : type.supertypes()) {
        // - The index x is less than x0.
        if (supertype_index.value() >= this_type_index)
            return Errors::invalid("supertype index, must precede the subtype"sv);

        // - The type C.types[x] exists.
        TRY(validate(supertype_index));

        // - The sub type unroll(C.types[x]) is of the form (sub y* comptype').
        auto const& supertype = m_context.types[supertype_index.value()];
        if (supertype.is_final())
            return Errors::invalid("supertype, must not be final"sv);

        // - The composite type comptype matches the composite type comptype'.
        auto const* defined_type = m_context.canonical_types[this_type_index];
        auto const* defined_supertype = m_context.canonical_types[supertype_index.value()];
        if (!matches_composite_type(defined_type->expansion(), defined_supertype->expansion(), TypeContext {}))
            return Errors::invalid("subtype, composite type must match its declared supertype"sv);
    }

    return type.description().visit(
        [&](FunctionType const& function) { return validate(function); },
        [&](StructType const& struct_) { return validate(struct_); },
        [&](ArrayType const& array) { return validate(array); });
}

ErrorOr<void, ValidationError> Validator::validate(FunctionType const& type)
{
    for (auto param : type.parameters()) {
        TRY(validate(param));
    }

    for (auto param : type.results()) {
        TRY(validate(param));
    }

    return {};
}

ErrorOr<void, ValidationError> Validator::validate(StructType const& type)
{
    for (auto field : type.fields()) {
        TRY(validate(field.type()));
    }

    return {};
}

ErrorOr<void, ValidationError> Validator::validate(ArrayType const& array)
{
    return validate(array.type().type());
}

ErrorOr<void, ValidationError> Validator::validate(GlobalType const& type)
{
    return validate(type.type());
}

ErrorOr<FunctionType, ValidationError> Validator::validate(BlockType const& type)
{
    if (type.kind() == BlockType::Index) {
        TRY(validate(type.type_index()));

        if (!m_context.types[type.type_index().value()].is_function())
            return Errors::invalid("BlockType"sv);

        return m_context.types[type.type_index().value()].function();
    }

    if (type.kind() == BlockType::Type) {
        FunctionType function_type { {}, { type.value_type() } };
        TRY(validate(function_type));
        return function_type;
    }

    if (type.kind() == BlockType::Empty)
        return FunctionType { {}, {} };

    return Errors::invalid("BlockType"sv);
}

ErrorOr<void, ValidationError> Validator::validate(Limits const& limits, Optional<u64> bound)
{
    auto check_bound = [bound](auto value) {
        if (!bound.has_value())
            return true;
        return static_cast<u64>(value) <= bound.value();
    };

    if (!check_bound(limits.min()))
        return Errors::out_of_bounds("limit minimum"sv, limits.min(), 0, bound);

    if (limits.max().has_value() && (limits.max().value() < limits.min() || !check_bound(*limits.max()))) {
        return Errors::out_of_bounds("limit maximum"sv, limits.max().value(), limits.min(), bound);
    }

    return {};
}

template<u64 opcode>
ErrorOr<void, ValidationError> Validator::validate_instruction(Instruction const& instruction, Stack&, bool&)
{
    return Errors::invalid(ByteString::formatted("instruction opcode ({:#x}) (missing validation!)", instruction.opcode().value()));
}

#define VALIDATE_INSTRUCTION(name) \
    template<>                     \
    ErrorOr<void, ValidationError> Validator::validate_instruction<Instructions::name.value()>([[maybe_unused]] Instruction const& instruction, [[maybe_unused]] Stack& stack, [[maybe_unused]] bool& is_constant)

// https://webassembly.github.io/spec/core/bikeshed/#-tmathsfhrefsyntax-instr-numericmathsfconstc
VALIDATE_INSTRUCTION(i32_const)
{
    is_constant = true;
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_const)
{
    is_constant = true;
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(f32_const)
{
    is_constant = true;
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_const)
{
    is_constant = true;
    stack.append(ValueType(ValueType::F64));
    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#-tmathsfhrefsyntax-unopmathitunop
VALIDATE_INSTRUCTION(i32_clz)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_ctz)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_popcnt)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_clz)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_ctz)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_popcnt)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(f32_abs)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_neg)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_sqrt)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_ceil)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_floor)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_trunc)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_nearest)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_abs)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_neg)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_sqrt)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_ceil)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_floor)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_trunc)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_nearest)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(i32_extend16_s)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_extend8_s)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_extend32_s)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_extend16_s)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_extend8_s)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I64));
    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#-tmathsfhrefsyntax-binopmathitbinop
VALIDATE_INSTRUCTION(i32_add)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    is_constant = true;
    return {};
}

VALIDATE_INSTRUCTION(i32_sub)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    is_constant = true;
    return {};
}

VALIDATE_INSTRUCTION(i32_mul)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    is_constant = true;
    return {};
}

VALIDATE_INSTRUCTION(i32_divs)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_divu)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_rems)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_remu)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_and)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_or)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_xor)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_shl)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_shrs)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_shru)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_rotl)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_rotr)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_add)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    is_constant = true;
    return {};
}

VALIDATE_INSTRUCTION(i64_sub)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    is_constant = true;
    return {};
}

VALIDATE_INSTRUCTION(i64_mul)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    is_constant = true;
    return {};
}

VALIDATE_INSTRUCTION(i64_divs)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_divu)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_rems)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_remu)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_and)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_or)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_xor)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_shl)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_shrs)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_shru)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_rotl)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_rotr)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(f32_add)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_sub)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_mul)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_div)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_min)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_max)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_copysign)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_add)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_sub)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_mul)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_div)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_min)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_max)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_copysign)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::F64));
    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#-tmathsfhrefsyntax-testopmathittestop
VALIDATE_INSTRUCTION(i32_eqz)
{
    TRY((stack.take<ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_eqz)
{
    TRY((stack.take<ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#-tmathsfhrefsyntax-relopmathitrelop
VALIDATE_INSTRUCTION(i32_eq)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_ne)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_lts)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_ltu)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_gts)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_gtu)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_les)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_leu)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_ges)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_geu)
{
    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_eq)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_ne)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_lts)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_ltu)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_gts)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_gtu)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_les)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_leu)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_ges)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_geu)
{
    TRY((stack.take<ValueType::I64, ValueType::I64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f32_eq)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f32_ne)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f32_lt)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f32_le)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f32_gt)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f32_ge)
{
    TRY((stack.take<ValueType::F32, ValueType::F32>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f64_eq)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f64_ne)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f64_lt)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f64_le)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f64_gt)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(f64_ge)
{
    TRY((stack.take<ValueType::F64, ValueType::F64>()));
    stack.append(ValueType(ValueType::I32));
    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#-t_2mathsfhrefsyntax-cvtopmathitcvtopmathsf_t_1mathsf_hrefsyntax-sxmathitsx
VALIDATE_INSTRUCTION(i32_wrap_i64)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_extend_si32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_extend_ui32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_sf32)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_uf32)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_sf64)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_uf64)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_sf32)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_uf32)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_sf64)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_uf64)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_sat_f32_s)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_sat_f32_u)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_sat_f64_s)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_trunc_sat_f64_u)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_sat_f32_s)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_sat_f32_u)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_sat_f64_s)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_trunc_sat_f64_u)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(f32_convert_si32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_convert_ui32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_convert_si64)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f32_convert_ui64)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_convert_si32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_convert_ui32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_convert_si64)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f64_convert_ui64)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f32_demote_f64)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_promote_f32)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(f32_reinterpret_i32)
{
    TRY(stack.take_and_put<ValueType::I32>(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_reinterpret_i64)
{
    TRY(stack.take_and_put<ValueType::I64>(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(i32_reinterpret_f32)
{
    TRY(stack.take_and_put<ValueType::F32>(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_reinterpret_f64)
{
    TRY(stack.take_and_put<ValueType::F64>(ValueType::I64));
    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#reference-instructions%E2%91%A2

VALIDATE_INSTRUCTION(ref_null)
{
    is_constant = true;
    stack.append(instruction.arguments().get<ValueType>());
    return {};
}

VALIDATE_INSTRUCTION(ref_is_null)
{
    if (stack.is_empty() || !stack.last().is_reference())
        return Errors::invalid_stack_state(stack, Tuple { "reference" });

    TRY(stack.take_last());
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(ref_func)
{
    auto index = instruction.arguments().get<FunctionIndex>();
    TRY(validate(index));

    if (m_context.references->tree.find(index.value()) == nullptr)
        return Errors::invalid("function reference"sv);

    is_constant = true;

    // https://webassembly.github.io/gc/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-ref-mathsf-ref-func-x
    // ref.func x : [] → [(ref dt)]
    auto type_index = m_context.function_type_indices[index.value()];
    auto ref_type = type_index.has_value() ? ValueType(ValueType::TypeUseReference, *type_index) : ValueType(ValueType::FunctionReference);
    ref_type.set_nullable(false);
    stack.append(ref_type);

    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#parametric-instructions%E2%91%A2
VALIDATE_INSTRUCTION(drop)
{
    TRY(stack.take_last());
    return {};
}

VALIDATE_INSTRUCTION(select)
{
    TRY(stack.take<ValueType::I32>());
    auto arg0_type = TRY(stack.take_last());
    auto arg1_type = TRY(stack.take_last());

    if (arg0_type != arg1_type || arg0_type.concrete_type.is_reference() || arg1_type.concrete_type.is_reference())
        return Errors::invalid("select argument types"sv, Vector { arg0_type, arg0_type }, Vector { arg0_type, arg1_type });

    stack.append(arg0_type.is_known ? arg0_type : arg1_type);

    return {};
}

VALIDATE_INSTRUCTION(select_typed)
{
    auto& required_types = instruction.arguments().get<Vector<ValueType>>();
    if (required_types.size() != 1)
        return Errors::invalid("select types"sv, "exactly one type"sv, required_types);

    // https://webassembly.github.io/spec/core/valid/instructions.html#parametric-instructions
    // select t: valid with [t t i32] -> [t] if the value type t is valid; both operands must match the annotated type.
    TRY(validate(required_types.first()));
    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(required_types.first()));
    TRY(stack.take(required_types.first()));

    stack.append(required_types.first());

    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#variable-instructions%E2%91%A2
// https://webassembly.github.io/spec/core/valid/instructions.html#variable-instructions
VALIDATE_INSTRUCTION(local_get)
{
    auto index = TRY(validate(instruction.local_index()));
    if (!m_local_initialized[index.value()])
        return Errors::invalid("local.get of an uninitialized non-defaultable local"sv);

    stack.append(m_context.locals[index.value()]);
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#variable-instructions
VALIDATE_INSTRUCTION(local_set)
{
    auto index = TRY(validate(instruction.local_index()));

    auto& value_type = m_context.locals[index.value()];
    TRY(stack.take(value_type));
    mark_local_initialized(index.value());

    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#variable-instructions
// local.tee x is valid with the instruction type t ->_x t; afterwards the local counts as
// initialized (the init set x).
VALIDATE_INSTRUCTION(local_tee)
{
    auto index = TRY(validate(instruction.local_index()));

    auto& value_type = m_context.locals[index.value()];
    TRY(stack.take(value_type));
    mark_local_initialized(index.value());
    stack.append(value_type);

    return {};
}

VALIDATE_INSTRUCTION(global_get)
{
    auto index = instruction.arguments().get<GlobalIndex>();
    TRY(validate(index));

    auto& global = m_context.globals[index.value()];

    is_constant = !global.is_mutable();
    stack.append(global.type());
    return {};
}

VALIDATE_INSTRUCTION(global_set)
{
    auto index = instruction.arguments().get<GlobalIndex>();
    TRY(validate(index));

    auto& global = m_context.globals[index.value()];

    if (!global.is_mutable())
        return Errors::invalid("global variable for global.set"sv);

    TRY(stack.take(global.type()));

    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#table-instructions%E2%91%A2
VALIDATE_INSTRUCTION(table_get)
{
    auto index = instruction.arguments().get<TableIndex>();
    auto table = TRY(validate(index));

    TRY(stack.take(table.limits().address_value_type()));
    stack.append(table.element_type());
    return {};
}

VALIDATE_INSTRUCTION(table_set)
{
    auto index = instruction.arguments().get<TableIndex>();
    auto table = TRY(validate(index));

    TRY(stack.take(table.element_type()));

    TRY(stack.take(table.limits().address_value_type()));

    return {};
}

VALIDATE_INSTRUCTION(table_size)
{
    auto index = instruction.arguments().get<TableIndex>();
    auto table = TRY(validate(index));

    stack.append(table.limits().address_value_type());
    return {};
}

VALIDATE_INSTRUCTION(table_grow)
{
    auto index = instruction.arguments().get<TableIndex>();
    auto table = TRY(validate(index));

    auto const at = table.limits().address_value_type();

    TRY(stack.take(at));
    TRY(stack.take(table.element_type()));

    stack.append(at);
    return {};
}

VALIDATE_INSTRUCTION(table_fill)
{
    auto index = instruction.arguments().get<TableIndex>();
    auto table = TRY(validate(index));

    TRY(stack.take(table.limits().address_value_type()));
    TRY(stack.take(table.element_type()));
    TRY(stack.take(table.limits().address_value_type()));

    return {};
}

VALIDATE_INSTRUCTION(table_copy)
{
    auto& args = instruction.arguments().get<Instruction::TableTableArgs>();

    auto lhs_table = TRY(validate(args.lhs));
    auto rhs_table = TRY(validate(args.rhs));

    if (!matches_reference_type(rhs_table.element_type(), lhs_table.element_type(), m_context.type_context()))
        return Errors::non_conforming_types("table.copy"sv, lhs_table.element_type(), rhs_table.element_type());

    auto const lhs_at = lhs_table.limits().address_value_type();
    auto const rhs_at = rhs_table.limits().address_value_type();
    auto const size_type = ValueType(lhs_at.kind() == ValueType::I32 || rhs_at.kind() == ValueType::I32 ? ValueType::I32 : ValueType::I64);

    TRY(stack.take(size_type));
    TRY(stack.take(rhs_at));
    TRY(stack.take(lhs_at));

    return {};
}

VALIDATE_INSTRUCTION(table_init)
{
    auto& args = instruction.arguments().get<Instruction::TableElementArgs>();

    auto table = TRY(validate(args.table_index));
    TRY(validate(args.element_index));

    auto& element_type = m_context.elements[args.element_index.value()];

    if (!matches_reference_type(element_type, table.element_type(), m_context.type_context()))
        return Errors::non_conforming_types("table.init"sv, table.element_type(), element_type);

    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    TRY((stack.take(table.limits().address_value_type())));

    return {};
}

VALIDATE_INSTRUCTION(elem_drop)
{
    auto index = instruction.arguments().get<ElementIndex>();
    TRY(validate(index));

    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#memory-instructions%E2%91%A2
VALIDATE_INSTRUCTION(i32_load)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(i32))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(i32));

    TRY((take_memory_address(stack, memory, arg)));

    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_load)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(i64))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(i64));

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(f32_load)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(float))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(float));

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::F32));
    return {};
}

VALIDATE_INSTRUCTION(f64_load)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(double))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(double));

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::F64));
    return {};
}

VALIDATE_INSTRUCTION(i32_load16_s)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 16 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 16 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_load16_u)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 16 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 16 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_load8_s)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 8 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 8 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i32_load8_u)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 8 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 8 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i64_load32_s)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 32 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 32 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_load32_u)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 32 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 32 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_load16_s)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 16 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 16 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_load16_u)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 16 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 16 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_load8_s)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 8 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 8 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i64_load8_u)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 8 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 8 / 8);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::I64));
    return {};
}

VALIDATE_INSTRUCTION(i32_store)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(i32))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(i32));

    TRY((stack.take<ValueType::I32>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(i64_store)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(i64))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(i64));

    TRY((stack.take<ValueType::I64>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(f32_store)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(float))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(float));

    TRY((stack.take<ValueType::F32>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(f64_store)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(double))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(double));

    TRY((stack.take<ValueType::F64>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(i32_store16)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 16 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 16 / 8);

    TRY((stack.take<ValueType::I32>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(i32_store8)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 8 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 8 / 8);

    TRY((stack.take<ValueType::I32>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(i64_store32)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 32 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 32 / 8);

    TRY((stack.take<ValueType::I64>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(i64_store16)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 16 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 16 / 8);

    TRY((stack.take<ValueType::I64>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(i64_store8)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > 8 / 8)
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, 8 / 8);

    TRY((stack.take<ValueType::I64>()));
    TRY((take_memory_address(stack, memory, arg)));

    return {};
}

VALIDATE_INSTRUCTION(memory_size)
{
    auto memory = TRY(validate(instruction.arguments().get<Instruction::MemoryIndexArgument>().memory_index));

    stack.append(memory.limits().address_value_type());
    return {};
}

VALIDATE_INSTRUCTION(memory_grow)
{
    auto memory = TRY(validate(instruction.arguments().get<Instruction::MemoryIndexArgument>().memory_index));

    auto const at = memory.limits().address_value_type();
    TRY((stack.take(at)));
    stack.append(at);

    return {};
}

VALIDATE_INSTRUCTION(memory_fill)
{
    auto memory = TRY(validate(instruction.arguments().get<Instruction::MemoryIndexArgument>().memory_index));

    TRY((take_memory_address(stack, memory, { 0, 0 })));
    TRY((stack.take<ValueType::I32>()));
    TRY((take_memory_address(stack, memory, { 0, 0 })));

    return {};
}

VALIDATE_INSTRUCTION(memory_copy)
{
    auto& args = instruction.arguments().get<Instruction::MemoryCopyArgs>();
    auto src_memory = TRY(validate(args.src_index));
    auto dst_memory = TRY(validate(args.dst_index));

    auto const src_at = ValueType(src_memory.limits().address_value_type());
    auto const dst_at = ValueType(dst_memory.limits().address_value_type());
    auto const size_at = ValueType(src_at.kind() == ValueType::I32 || dst_at.kind() == ValueType::I32 ? ValueType::I32 : ValueType::I64);

    TRY((stack.take(size_at)));
    TRY((stack.take(src_at)));
    TRY((stack.take(dst_at)));

    return {};
}

VALIDATE_INSTRUCTION(memory_init)
{
    if (!m_context.data_count.has_value())
        return Errors::invalid("memory.init, requires data count section"sv);

    auto& args = instruction.arguments().get<Instruction::MemoryInitArgs>();

    auto memory = TRY(validate(args.memory_index));
    TRY(validate(args.data_index));

    auto const at = memory.limits().address_value_type();

    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    TRY((stack.take(at)));

    return {};
}

VALIDATE_INSTRUCTION(data_drop)
{
    if (!m_context.data_count.has_value())
        return Errors::invalid("data.drop, requires data count section"sv);

    auto index = instruction.arguments().get<DataIndex>();
    TRY(validate(index));

    return {};
}

// https://webassembly.github.io/spec/core/bikeshed/#control-instructions%E2%91%A2
VALIDATE_INSTRUCTION(nop)
{
    return {};
}

VALIDATE_INSTRUCTION(unreachable)
{
    // https://webassembly.github.io/spec/core/bikeshed/#polymorphism
    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

// Note: This is responsible for _all_ structured instructions, and is *not* from the spec.
VALIDATE_INSTRUCTION(structured_end)
{
    if (m_frames.is_empty())
        return Errors::invalid("usage of structured end"sv);

    auto& last_frame = m_frames.last();

    // If this is true, then the `if` had no else. In that case, validate that the
    // empty else block produces the correct type.
    if (last_frame.kind == FrameKind::If) {
        bool is_constant = false;
        TRY(validate(Instruction(Instructions::structured_else), stack, is_constant));
    }

    auto& results = last_frame.type.results();
    for (size_t i = 1; i <= results.size(); ++i)
        TRY(stack.take(results[results.size() - i]));

    if (stack.size() != last_frame.initial_size)
        return Errors::stack_height_mismatch(stack, last_frame.initial_size);

    for (auto& result : results)
        stack.append(result);

    // Locals initialized within the block become uninitialized again when it exits.
    // https://webassembly.github.io/spec/core/appendix/algorithm.html
    roll_back_local_initializations(last_frame.local_init_log_height);
    m_frames.take_last();

    return {};
}

// Note: This is *not* from the spec.
VALIDATE_INSTRUCTION(structured_else)
{
    if (m_frames.is_empty())
        return Errors::invalid("usage of structured else"sv);

    if (m_frames.last().kind != FrameKind::If)
        return Errors::invalid("usage of structured else"sv);

    auto& frame = m_frames.last();
    auto& block_type = frame.type;
    auto& results = block_type.results();

    for (size_t i = 1; i <= results.size(); ++i)
        TRY(stack.take(results[results.size() - i]));

    if (stack.size() != frame.initial_size)
        return Errors::stack_height_mismatch(stack, frame.initial_size);

    frame.kind = FrameKind::Else;
    frame.unreachable = false;

    // https://webassembly.github.io/spec/core/appendix/algorithm.html
    roll_back_local_initializations(frame.local_init_log_height);

    for (auto& parameter : block_type.parameters())
        stack.append(parameter);

    return {};
}

VALIDATE_INSTRUCTION(block)
{
    auto& args = instruction.arguments().get<Instruction::StructuredInstructionArgs>();
    auto block_type = TRY(validate(args.block_type));

    auto& parameters = block_type.parameters();
    for (size_t i = 1; i <= parameters.size(); ++i)
        TRY(stack.take(parameters[parameters.size() - i]));

    push_frame(Frame { block_type, FrameKind::Block, stack.size() });
    for (auto& parameter : parameters)
        stack.append(parameter);

    args.meta = Instruction::StructuredInstructionArgs::Meta {
        .arity = static_cast<u32>(block_type.results().size()),
        .parameter_count = static_cast<u32>(parameters.size()),
        .tier_up_eligible = false,
    };

    return {};
}

VALIDATE_INSTRUCTION(loop)
{
    auto& args = instruction.arguments().get<Instruction::StructuredInstructionArgs>();
    auto block_type = TRY(validate(args.block_type));

    auto& parameters = block_type.parameters();
    for (size_t i = 1; i <= parameters.size(); ++i)
        TRY(stack.take(parameters[parameters.size() - i]));

    auto const tier_up_eligible = parameters.is_empty() && stack.size() == 0;

    push_frame(Frame { block_type, FrameKind::Loop, stack.size() });
    for (auto& parameter : parameters)
        stack.append(parameter);

    args.meta = Instruction::StructuredInstructionArgs::Meta {
        .arity = static_cast<u32>(block_type.results().size()),
        .parameter_count = static_cast<u32>(parameters.size()),
        .tier_up_eligible = tier_up_eligible,
    };

    return {};
}

VALIDATE_INSTRUCTION(if_)
{
    auto& args = instruction.arguments().get<Instruction::StructuredInstructionArgs>();
    auto block_type = TRY(validate(args.block_type));

    TRY(stack.take<ValueType::I32>());

    auto stack_snapshot = stack;

    auto& parameters = block_type.parameters();
    for (size_t i = 1; i <= parameters.size(); ++i)
        TRY(stack.take(parameters[parameters.size() - i]));

    push_frame(Frame { block_type, FrameKind::If, stack.size() });
    for (auto& parameter : parameters)
        stack.append(parameter);

    args.meta = Instruction::StructuredInstructionArgs::Meta {
        .arity = static_cast<u32>(block_type.results().size()),
        .parameter_count = static_cast<u32>(parameters.size()),
        .tier_up_eligible = false,
    };

    return {};
}

// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-throw-x
VALIDATE_INSTRUCTION(throw_)
{
    auto tag_index = instruction.arguments().get<TagIndex>();
    TRY(validate(tag_index));

    auto tag_type = m_context.tags[tag_index.value()];
    TRY(validate(tag_type.type()));
    auto& type = m_context.types[tag_type.type().value()];

    if (!type.is_function())
        return Errors::invalid("throw type"sv, "a function type"sv, type);

    auto& func = type.function();

    if (!func.results().is_empty())
        return Errors::invalid("throw type"sv, "empty"sv, func.results());

    for (auto const& parameter : func.parameters().in_reverse())
        TRY(stack.take(parameter));

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-throw-ref
VALIDATE_INSTRUCTION(throw_ref)
{
    TRY(stack.take<ValueType::ExceptionReference>());
    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);
    return {};
}

// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-try-table-xref-syntax-instructions-syntax-blocktype-mathit-blocktype-xref-syntax-instructions-syntax-catch-mathit-catch-ast-xref-syntax-instructions-syntax-instr-mathit-instr-ast-xref-syntax-instructions-syntax-instr-control-mathsf-end
// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-catch-x-l
// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-catch-ref-x-l
// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-catch-all-l
// https://webassembly.github.io/exception-handling/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-catch-all-ref-l
VALIDATE_INSTRUCTION(try_table)
{
    auto& args = instruction.arguments().get<Instruction::TryTableArgs>();
    auto block_type = TRY(validate(args.block_type));

    // https://webassembly.github.io/spec/core/valid/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-try-table-xref-syntax-types-syntax-blocktype-mathit-blocktype-xref-syntax-instructions-syntax-catch-mathit-catch-ast-xref-syntax-instructions-syntax-instr-mathit-instr-ast
    // try_table bt catch* instr* is valid with [t1*] -> [t2*] if:
    //  - The block type bt is valid as some instruction type [t1*] -> [t2*].
    //  - For all catch in catch*: the catch clause catch is valid.
    //    Note: the catch clauses are validated under C, without the try_table's own label.
    for (auto& catch_ : args.catches()) {
        // - The label C.labels[l] exists.
        auto label = catch_.target_label();
        TRY(validate(label));
        auto& target_label_type = m_frames[(m_frames.size() - 1) - label.value()].labels();

        Vector<ValueType> expected_label_types;
        if (auto tag = catch_.matching_tag_index(); tag.has_value()) {
            // - The tag C.tags[x] exists.
            TRY(validate(tag.value()));
            auto tag_type = m_context.tags[tag->value()];
            TRY(validate(tag_type.type()));
            auto& type = m_context.types[tag_type.type().value()];

            // - The expansion of C.tags[x] is (func t* -> ε).
            if (!type.is_function())
                return Errors::invalid("catch tag type"sv, "a function type"sv, type);
            auto& func = type.function();
            if (!func.results().is_empty())
                return Errors::invalid("catch tag type"sv, "no results"sv, func.results());

            expected_label_types.extend(func.parameters());
        }

        // catch x l:         the result type t* matches the label C.labels[l].
        // catch_ref x l:     the result type t* (ref exn) matches the label C.labels[l].
        // catch_all l:       the result type ε matches the label C.labels[l].
        // catch_all_ref l:   the result type (ref exn) matches the label C.labels[l].
        if (catch_.is_ref())
            expected_label_types.append(ValueType(ValueType::ExceptionReference, false));

        if (!matches_result_types(expected_label_types.span(), target_label_type.span(), m_context.type_context()))
            return Errors::non_conforming_types("catch"sv, expected_label_types.span(), target_label_type.span());
    }

    auto& parameters = block_type.parameters();
    for (size_t i = 1; i <= parameters.size(); ++i)
        TRY(stack.take(parameters[parameters.size() - i]));

    args.meta = Instruction::TryTableArgs::Meta {
        .arity = static_cast<u32>(block_type.results().size()),
        .parameter_count = static_cast<u32>(parameters.size()),
        .tier_up_eligible = false,
    };

    push_frame(Frame { block_type, FrameKind::TryTable, stack.size() });
    for (auto& parameter : parameters)
        stack.append(parameter);

    return {};
}

VALIDATE_INSTRUCTION(br)
{
    auto& args = instruction.arguments().get<Instruction::BranchArgs>();
    TRY(validate(args.label));

    auto& target = m_frames[(m_frames.size() - 1) - args.label.value()];

    auto& type = target.labels();
    for (size_t i = 1; i <= type.size(); ++i)
        TRY(stack.take(type[type.size() - i]));

    args.has_stack_adjustment = target.initial_size != stack.size();

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);
    return {};
}

VALIDATE_INSTRUCTION(br_if)
{
    auto& args = instruction.arguments().get<Instruction::BranchArgs>();
    TRY(validate(args.label));

    TRY(stack.take<ValueType::I32>());

    auto& target = m_frames[(m_frames.size() - 1) - args.label.value()];
    auto& type = target.labels();

    Vector<StackEntry> entries;
    entries.ensure_capacity(type.size());

    for (size_t i = 0; i < type.size(); ++i) {
        auto& entry = type[type.size() - i - 1];
        TRY(stack.take(entry));
        entries.append(entry);
    }

    for (size_t i = 0; i < entries.size(); ++i)
        stack.append(entries[entries.size() - i - 1]);

    args.has_stack_adjustment = target.initial_size != stack.size();

    return {};
}

VALIDATE_INSTRUCTION(br_table)
{
    auto& args = instruction.arguments().get<Instruction::TableBranchArgs>();
    TRY(validate(args.default_));

    for (auto& label : args.labels)
        TRY(validate(label));

    TRY(stack.take<ValueType::I32>());

    auto& default_types = m_frames[(m_frames.size() - 1) - args.default_.value()].labels();
    auto arity = default_types.size();

    for (auto& label : args.labels) {
        auto& label_types = m_frames[(m_frames.size() - 1) - label.value()].labels();
        if (label_types.size() != arity)
            return Errors::invalid("br_table label arity mismatch"sv);
        Vector<StackEntry> popped {};
        for (size_t i = 0; i < arity; ++i) {
            auto stack_entry = TRY(stack.take(label_types[label_types.size() - i - 1]));
            popped.append(stack_entry);
        }
        for (auto popped_type : popped.in_reverse())
            stack.append(popped_type);
    }

    for (size_t i = 0; i < arity; ++i) {
        auto expected = default_types[default_types.size() - i - 1];
        TRY((stack.take(expected)));
    }

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

VALIDATE_INSTRUCTION(return_)
{
    auto& return_types = m_frames.first().type.results();
    for (size_t i = 0; i < return_types.size(); ++i)
        TRY((stack.take(return_types[return_types.size() - i - 1])));

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

VALIDATE_INSTRUCTION(call)
{
    auto index = instruction.arguments().get<FunctionIndex>();
    TRY(validate(index));

    auto& function_type = m_context.functions[index.value()];
    for (size_t i = 0; i < function_type.parameters().size(); ++i)
        TRY(stack.take(function_type.parameters()[function_type.parameters().size() - i - 1]));

    for (auto& type : function_type.results())
        stack.append(type);

    return {};
}

VALIDATE_INSTRUCTION(call_indirect)
{
    auto& args = instruction.arguments().get<Instruction::IndirectCallArgs>();
    auto table = TRY(validate(args.table));
    TRY(validate(args.type));

    if (!matches_reference_type(table.element_type(), ValueType(ValueType::FunctionReference), m_context.type_context()))
        return Errors::invalid("table element type for call.indirect"sv, "a function reference"sv, table.element_type());

    auto& type = m_context.types[args.type.value()];

    if (!type.is_function())
        return Errors::invalid("type for call.indirect"sv, "a function type"sv, type);

    auto& func = type.function();
    TRY(stack.take(table.limits().address_value_type()));

    for (size_t i = 0; i < func.parameters().size(); ++i)
        TRY(stack.take(func.parameters()[func.parameters().size() - i - 1]));

    for (auto& type : func.results())
        stack.append(type);

    return {};
}

VALIDATE_INSTRUCTION(return_call)
{
    auto index = instruction.arguments().get<FunctionIndex>();
    TRY(validate(index));

    auto& function_type = m_context.functions[index.value()];
    for (size_t i = 0; i < function_type.parameters().size(); ++i)
        TRY(stack.take(function_type.parameters()[function_type.parameters().size() - i - 1]));

    auto const& return_types = m_frames.first().type.results();
    if (return_types != function_type.results())
        return Errors::invalid("return_call target"sv, function_type.results(), return_types);

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

VALIDATE_INSTRUCTION(return_call_indirect)
{
    auto& args = instruction.arguments().get<Instruction::IndirectCallArgs>();
    TRY(validate(args.table));
    TRY(validate(args.type));

    auto& table = m_context.tables[args.table.value()];
    if (!matches_reference_type(table.element_type(), ValueType(ValueType::FunctionReference), m_context.type_context()))
        return Errors::invalid("table element type for call.indirect"sv, "a function reference"sv, table.element_type());

    auto& type = m_context.types[args.type.value()];
    if (!type.is_function())
        return Errors::invalid("type for return_call_indirect"sv, "a function type"sv, table.element_type());

    auto& func = type.function();

    TRY(stack.take<ValueType::I32>());

    for (size_t i = 0; i < func.parameters().size(); ++i)
        TRY(stack.take(func.parameters()[func.parameters().size() - i - 1]));

    auto& return_types = m_frames.first().type.results();
    if (return_types != func.results())
        return Errors::invalid("return_call_indirect target"sv, func.results(), return_types);

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

VALIDATE_INSTRUCTION(call_ref)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    TRY(validate(type_index));

    auto const& type = m_context.types[type_index.value()];
    if (!type.is_function())
        return Errors::invalid("type for call_ref"sv, "a function type"sv, type);

    auto const& func = type.function();

    TRY(stack.take(ValueType(ValueType::TypeUseReference, type_index)));

    for (size_t i = 0; i < func.parameters().size(); ++i)
        TRY(stack.take(func.parameters()[func.parameters().size() - i - 1]));

    for (auto const& type : func.results())
        stack.append(type);

    return {};
}

VALIDATE_INSTRUCTION(return_call_ref)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    TRY(validate(type_index));

    auto const& type = m_context.types[type_index.value()];
    if (!type.is_function())
        return Errors::invalid("type for return_call_ref"sv, "a function type"sv, type);

    auto const& func = type.function();

    TRY(stack.take(ValueType(ValueType::TypeUseReference, type_index)));

    for (size_t i = 0; i < func.parameters().size(); ++i)
        TRY(stack.take(func.parameters()[func.parameters().size() - i - 1]));

    auto const& return_types = m_frames.first().type.results();
    auto const& callee_results = func.results();
    if (return_types.size() != callee_results.size())
        return Errors::invalid("return_call_ref target"sv, callee_results, return_types);
    for (size_t i = 0; i < return_types.size(); ++i) {
        StackEntry entry { callee_results[i] };
        if (entry != return_types[i])
            return Errors::invalid("return_call_ref target"sv, callee_results, return_types);
    }

    m_frames.last().unreachable = true;
    stack.resize(m_frames.last().initial_size);

    return {};
}

VALIDATE_INSTRUCTION(v128_load)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(u128))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(u128));

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::V128));

    return {};
}

VALIDATE_INSTRUCTION(v128_load8x8_s)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 8;
    constexpr auto M = 8;
    constexpr auto max_alignment = N * M / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load8x8_u)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 8;
    constexpr auto M = 8;
    constexpr auto max_alignment = N * M / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load16x4_s)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 16;
    constexpr auto M = 4;
    constexpr auto max_alignment = N * M / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load16x4_u)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 16;
    constexpr auto M = 4;
    constexpr auto max_alignment = N * M / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load32x2_s)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 32;
    constexpr auto M = 2;
    constexpr auto max_alignment = N * M / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load32x2_u)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 32;
    constexpr auto M = 2;
    constexpr auto max_alignment = N * M / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load8_splat)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 8;
    constexpr auto max_alignment = N / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load16_splat)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 16;
    constexpr auto max_alignment = N / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load32_splat)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 32;
    constexpr auto max_alignment = N / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_load64_splat)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 64;
    constexpr auto max_alignment = N / 8;

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    return stack.take_and_put<ValueType::I32>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_store)
{
    auto& arg = instruction.arguments().get<Instruction::MemoryArgument>();

    TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1ull << arg.align) > sizeof(u128))
        return Errors::out_of_bounds("memory op alignment"sv, 1ull << arg.align, 0, sizeof(u128));

    TRY((stack.take<ValueType::V128, ValueType::I32>()));

    return {};
}

VALIDATE_INSTRUCTION(v128_const)
{
    is_constant = true;
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(i8x16_shuffle)
{
    auto const& arg = instruction.arguments().get<Instruction::ShuffleArgument>();
    for (auto lane : arg.lanes) {
        if (lane >= 32)
            return Errors::out_of_bounds("shuffle lane"sv, lane, 0, 32);
    }
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_swizzle)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

enum class Shape {
    I8x16,
    I16x8,
    I32x4,
    I64x2,
    F32x4,
    F64x2,
};

template<Shape shape>
static constexpr Wasm::ValueType::Kind unpacked()
{
    switch (shape) {
    case Shape::I8x16:
    case Shape::I16x8:
    case Shape::I32x4:
        return Wasm::ValueType::I32;
    case Shape::I64x2:
        return Wasm::ValueType::I64;
    case Shape::F32x4:
        return Wasm::ValueType::F32;
    case Shape::F64x2:
        return Wasm::ValueType::F64;
    }
}

template<Shape shape>
static constexpr size_t dimensions()
{
    switch (shape) {
    case Shape::I8x16:
        return 16;
    case Shape::I16x8:
        return 8;
    case Shape::I32x4:
        return 4;
    case Shape::I64x2:
        return 2;
    case Shape::F32x4:
        return 4;
    case Shape::F64x2:
        return 2;
    }
}

VALIDATE_INSTRUCTION(i8x16_splat)
{
    constexpr auto unpacked_shape = unpacked<Shape::I8x16>();
    return stack.take_and_put<unpacked_shape>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_splat)
{
    constexpr auto unpacked_shape = unpacked<Shape::I16x8>();
    return stack.take_and_put<unpacked_shape>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_splat)
{
    constexpr auto unpacked_shape = unpacked<Shape::I32x4>();
    return stack.take_and_put<unpacked_shape>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_splat)
{
    constexpr auto unpacked_shape = unpacked<Shape::I64x2>();
    return stack.take_and_put<unpacked_shape>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_splat)
{
    constexpr auto unpacked_shape = unpacked<Shape::F32x4>();
    return stack.take_and_put<unpacked_shape>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_splat)
{
    constexpr auto unpacked_shape = unpacked<Shape::F64x2>();
    return stack.take_and_put<unpacked_shape>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_extract_lane_s)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I8x16;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(i8x16_extract_lane_u)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I8x16;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(i8x16_replace_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I8x16;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<unpacked<shape>(), ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extract_lane_s)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I16x8;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(i16x8_extract_lane_u)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I16x8;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(i16x8_replace_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I16x8;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<unpacked<shape>(), ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extract_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I32x4;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(i32x4_replace_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I32x4;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<unpacked<shape>(), ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extract_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I64x2;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(i64x2_replace_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::I64x2;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<unpacked<shape>(), ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_extract_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::F32x4;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(f32x4_replace_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::F32x4;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<unpacked<shape>(), ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_extract_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::F64x2;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<ValueType::V128>(unpacked<shape>());
}

VALIDATE_INSTRUCTION(f64x2_replace_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::LaneIndex>();
    constexpr auto shape = Shape::F64x2;
    constexpr auto max_lane = dimensions<shape>();

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("extract lane"sv, arg.lane, 0, max_lane);
    return stack.take_and_put<unpacked<shape>(), ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_eq)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_ne)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_lt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_lt_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_gt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_gt_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_le_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_le_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_ge_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_ge_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_eq)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_ne)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_lt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_lt_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_gt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_gt_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_le_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_le_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_ge_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_ge_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_eq)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_ne)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_lt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_lt_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_gt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_gt_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_le_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_le_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_ge_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_ge_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_eq)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_ne)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_lt)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_gt)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_le)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_ge)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_eq)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_ne)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_lt)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_gt)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_le)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_ge)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_not)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_and)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_andnot)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_or)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_xor)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_bitselect)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(v128_any_true)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(v128_load8_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 8;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(v128_load16_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 16;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(v128_load32_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 32;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(v128_load64_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 64;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(v128_store8_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 8;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    return {};
}

VALIDATE_INSTRUCTION(v128_store16_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 16;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    return {};
}

VALIDATE_INSTRUCTION(v128_store32_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 32;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    return {};
}

VALIDATE_INSTRUCTION(v128_store64_lane)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryAndLaneArgument>();
    constexpr auto N = 64;
    constexpr auto max_lane = 128 / N;
    constexpr auto max_alignment = N / 8;

    if (arg.lane >= max_lane)
        return Errors::out_of_bounds("lane index"sv, arg.lane, 0u, max_lane);

    auto memory = TRY(validate(arg.memory.memory_index));

    if (arg.memory.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.memory.align, 0, 64);

    if ((1 << arg.memory.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.memory.align, 0u, max_alignment);

    TRY((stack.take<ValueType::V128>()));
    TRY((take_memory_address(stack, memory, arg.memory)));
    return {};
}

VALIDATE_INSTRUCTION(v128_load32_zero)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 32;
    constexpr auto max_alignment = N / 8;

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(v128_load64_zero)
{
    auto const& arg = instruction.arguments().get<Instruction::MemoryArgument>();
    constexpr auto N = 64;
    constexpr auto max_alignment = N / 8;

    auto memory = TRY(validate(arg.memory_index));

    if (arg.align > 64)
        return Errors::out_of_bounds("memory op alignment value"sv, arg.align, 0, 64);

    if ((1 << arg.align) > max_alignment)
        return Errors::out_of_bounds("memory op alignment"sv, 1 << arg.align, 0u, max_alignment);

    TRY((take_memory_address(stack, memory, arg)));
    stack.append(ValueType(ValueType::V128));
    return {};
}

VALIDATE_INSTRUCTION(f32x4_demote_f64x2_zero)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_promote_low_f32x4)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_abs)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_neg)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_popcnt)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_all_true)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i8x16_bitmask)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i8x16_narrow_i16x8_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_narrow_i16x8_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_ceil)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_floor)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_trunc)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_nearest)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_shl)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_shr_s)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_shr_u)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_add)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_add_sat_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_add_sat_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_sub)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_sub_sat_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_sub_sat_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_ceil)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_floor)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_min_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_min_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_max_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_max_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_trunc)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_avgr_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extadd_pairwise_i8x16_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extadd_pairwise_i8x16_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extadd_pairwise_i16x8_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extadd_pairwise_i16x8_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_abs)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_neg)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_q15mulr_sat_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_all_true)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i16x8_bitmask)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i16x8_narrow_i32x4_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_narrow_i32x4_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extend_low_i8x16_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extend_high_i8x16_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extend_low_i8x16_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extend_high_i8x16_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_shl)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_shr_s)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_shr_u)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_add)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_add_sat_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_add_sat_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_sub)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_sub_sat_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_sub_sat_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_nearest)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_mul)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_min_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_min_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_max_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_max_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_avgr_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extmul_low_i8x16_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extmul_high_i8x16_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extmul_low_i8x16_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_extmul_high_i8x16_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_abs)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_neg)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_all_true)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i32x4_bitmask)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i32x4_extend_low_i16x8_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extend_high_i16x8_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extend_low_i16x8_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extend_high_i16x8_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_shl)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_shr_s)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_shr_u)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_add)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_sub)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_mul)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_min_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_min_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_max_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_max_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_dot_i16x8_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extmul_low_i16x8_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extmul_high_i16x8_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extmul_low_i16x8_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_extmul_high_i16x8_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_abs)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_neg)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_all_true)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i64x2_bitmask)
{
    return stack.take_and_put<ValueType::V128>(ValueType::I32);
}

VALIDATE_INSTRUCTION(i64x2_extend_low_i32x4_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extend_high_i32x4_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extend_low_i32x4_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extend_high_i32x4_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_shl)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_shr_s)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_shr_u)
{
    return stack.take_and_put<ValueType::I32, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_add)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_sub)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_mul)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_eq)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_ne)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_lt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_gt_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_le_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_ge_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extmul_low_i32x4_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extmul_high_i32x4_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extmul_low_i32x4_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_extmul_high_i32x4_u)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_abs)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_neg)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_sqrt)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_add)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_sub)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_mul)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_div)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_min)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_max)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_pmin)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_pmax)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_abs)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_neg)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_sqrt)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_add)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_sub)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_mul)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_div)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_min)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_max)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_pmin)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_pmax)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_trunc_sat_f32x4_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_trunc_sat_f32x4_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_convert_i32x4_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_convert_i32x4_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_trunc_sat_f64x2_s_zero)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_trunc_sat_f64x2_u_zero)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_convert_low_i32x4_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_convert_low_i32x4_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_relaxed_swizzle)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_relaxed_trunc_f32x4_s)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_relaxed_trunc_f32x4_u)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_relaxed_trunc_f64x2_s_zero)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_relaxed_trunc_f64x2_u_zero)
{
    return stack.take_and_put<ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_relaxed_madd)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_relaxed_nmadd)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_relaxed_madd)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_relaxed_nmadd)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i8x16_relaxed_laneselect)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_relaxed_laneselect)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_relaxed_laneselect)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i64x2_relaxed_laneselect)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_relaxed_min)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f32x4_relaxed_max)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_relaxed_min)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(f64x2_relaxed_max)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_relaxed_q15mulr_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i16x8_relaxed_dot_i8x16_i7x16_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128>(ValueType::V128);
}

VALIDATE_INSTRUCTION(i32x4_relaxed_dot_i8x16_i7x16_add_s)
{
    return stack.take_and_put<ValueType::V128, ValueType::V128, ValueType::V128>(ValueType::V128);
}

// https://webassembly.github.io/spec/core/valid/instructions.html#reference-instructions
VALIDATE_INSTRUCTION(ref_eq)
{
    TRY(stack.take(ValueType(ValueType::EqReference)));
    TRY(stack.take(ValueType(ValueType::EqReference)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#reference-instructions
VALIDATE_INSTRUCTION(ref_as_non_null)
{
    auto entry = TRY(stack.take_last());
    if (entry.is_known && !entry.concrete_type.is_reference())
        return Errors::invalid_stack_state(stack, Tuple { "reference" });

    if (entry.is_known) {
        auto type = entry.concrete_type;
        type.set_nullable(false);
        stack.append(type);
    } else {
        stack.append(entry);
    }
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#control-instructions
VALIDATE_INSTRUCTION(br_on_null)
{
    auto& args = instruction.arguments().get<Instruction::BranchArgs>();
    TRY(validate(args.label));

    auto entry = TRY(stack.take_last());
    if (entry.is_known && !entry.concrete_type.is_reference())
        return Errors::invalid_stack_state(stack, Tuple { "reference" });

    auto& target = m_frames[(m_frames.size() - 1) - args.label.value()];
    auto& type = target.labels();

    for (size_t i = 0; i < type.size(); ++i)
        TRY(stack.take(type[type.size() - i - 1]));
    for (auto& label_type : type)
        stack.append(label_type);

    if (entry.is_known) {
        auto result = entry.concrete_type;
        result.set_nullable(false);
        stack.append(result);
    } else {
        stack.append(entry);
    }

    args.has_stack_adjustment = target.initial_size != stack.size();
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#control-instructions
VALIDATE_INSTRUCTION(br_on_non_null)
{
    auto& args = instruction.arguments().get<Instruction::BranchArgs>();
    TRY(validate(args.label));

    auto& target = m_frames[(m_frames.size() - 1) - args.label.value()];
    auto& type = target.labels();
    if (type.is_empty() || !type.last().is_reference())
        return Errors::invalid("br_on_non_null label type"sv, "t* (ref null? ht)"sv, type);

    auto expected = type.last();
    expected.set_nullable(true);
    TRY(stack.take(expected));

    for (size_t i = 0; i + 1 < type.size(); ++i)
        TRY(stack.take(type[type.size() - i - 2]));
    for (size_t i = 0; i + 1 < type.size(); ++i)
        stack.append(type[i]);

    args.has_stack_adjustment = target.initial_size != stack.size();
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(struct_new)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    TRY(validate(type_index));
    auto const& type = m_context.types[type_index.value()];
    if (!type.is_struct())
        return Errors::invalid("struct.new type"sv, "a struct type"sv, type);

    auto& fields = type.struct_().fields();
    for (size_t i = 0; i < fields.size(); ++i)
        TRY(stack.take(fields[fields.size() - i - 1].type().unpacked()));

    stack.append(ValueType(ValueType::TypeUseReference, type_index, false));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(struct_new_default)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    TRY(validate(type_index));
    auto const& type = m_context.types[type_index.value()];
    if (!type.is_struct())
        return Errors::invalid("struct.new_default type"sv, "a struct type"sv, type);

    for (auto& field : type.struct_().fields()) {
        if (!field.type().is_defaultable())
            return Errors::invalid("struct.new_default field type, must be defaultable"sv);
    }

    stack.append(ValueType(ValueType::TypeUseReference, type_index, false));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
ErrorOr<void, ValidationError> Validator::validate_struct_get(Stack& stack, Instruction const& instruction, bool requires_packed)
{
    auto& args = instruction.arguments().get<Instruction::StructFieldArgs>();
    TRY(validate(args.type_index));
    auto const& type = m_context.types[args.type_index.value()];
    if (!type.is_struct())
        return Errors::invalid("struct.get type"sv, "a struct type"sv, type);

    auto& fields = type.struct_().fields();
    if (args.field_index >= fields.size())
        return Errors::invalid("struct.get field index"sv);
    auto field_type = fields[args.field_index].type();
    if (field_type.is_packed() != requires_packed)
        return Errors::invalid("struct.get signedness, present iff the field type is packed"sv);

    TRY(stack.take(ValueType(ValueType::TypeUseReference, args.type_index)));
    stack.append(field_type.unpacked());
    return {};
}

VALIDATE_INSTRUCTION(struct_get)
{
    return validate_struct_get(stack, instruction, false);
}

VALIDATE_INSTRUCTION(struct_get_s)
{
    return validate_struct_get(stack, instruction, true);
}

VALIDATE_INSTRUCTION(struct_get_u)
{
    return validate_struct_get(stack, instruction, true);
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(struct_set)
{
    auto& args = instruction.arguments().get<Instruction::StructFieldArgs>();
    TRY(validate(args.type_index));
    auto const& type = m_context.types[args.type_index.value()];
    if (!type.is_struct())
        return Errors::invalid("struct.set type"sv, "a struct type"sv, type);

    auto& fields = type.struct_().fields();
    if (args.field_index >= fields.size())
        return Errors::invalid("struct.set field index"sv);
    auto& field = fields[args.field_index];
    if (!field.is_mutable())
        return Errors::invalid("struct.set field, must be mutable"sv);

    TRY(stack.take(field.type().unpacked()));
    TRY(stack.take(ValueType(ValueType::TypeUseReference, args.type_index)));
    return {};
}

ErrorOr<FieldType, ValidationError> Validator::array_field_type(TypeIndex type_index, StringView instruction_name, bool requires_mutable)
{
    TRY(validate(type_index));
    auto const& type = m_context.types[type_index.value()];
    if (!type.is_array())
        return Errors::invalid(instruction_name, "an array type"sv, type);
    if (requires_mutable && !type.array().type().is_mutable())
        return Errors::invalid(instruction_name, "a mutable array type"sv, type);
    return type.array().type();
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_new)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    auto field = TRY(array_field_type(type_index, "array.new type"sv, false));

    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(field.type().unpacked()));
    stack.append(ValueType(ValueType::TypeUseReference, type_index, false));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_new_default)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    auto field = TRY(array_field_type(type_index, "array.new_default type"sv, false));
    if (!field.type().is_defaultable())
        return Errors::invalid("array.new_default element type, must be defaultable"sv);

    TRY(stack.take<ValueType::I32>());
    stack.append(ValueType(ValueType::TypeUseReference, type_index, false));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_new_fixed)
{
    auto& args = instruction.arguments().get<Instruction::ArrayNewFixedArgs>();
    auto field = TRY(array_field_type(args.type_index, "array.new_fixed type"sv, false));

    for (size_t i = 0; i < args.count; ++i)
        TRY(stack.take(field.type().unpacked()));
    stack.append(ValueType(ValueType::TypeUseReference, args.type_index, false));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_new_data)
{
    auto& args = instruction.arguments().get<Instruction::ArrayDataArgs>();
    auto field = TRY(array_field_type(args.type_index, "array.new_data type"sv, false));
    if (field.type().is_reference())
        return Errors::invalid("array.new_data element type"sv, "a numeric or vector type"sv, field.type());

    if (!m_context.data_count.has_value())
        return Errors::invalid("array.new_data, requires data count section"sv);
    TRY(validate(args.data_index));

    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::TypeUseReference, args.type_index, false));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_new_elem)
{
    auto& args = instruction.arguments().get<Instruction::ArrayElemArgs>();
    auto field = TRY(array_field_type(args.type_index, "array.new_elem type"sv, false));
    if (!field.type().is_reference())
        return Errors::invalid("array.new_elem element type"sv, "a reference type"sv, field.type());

    TRY(validate(args.element_index));
    auto segment_type = m_context.elements[args.element_index.value()];
    if (!matches_reference_type(segment_type, field.type(), m_context.type_context()))
        return Errors::invalid("array.new_elem element segment type"sv, field.type(), segment_type);

    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    stack.append(ValueType(ValueType::TypeUseReference, args.type_index, false));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
ErrorOr<void, ValidationError> Validator::validate_array_get(Stack& stack, Instruction const& instruction, bool requires_packed)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    auto field = TRY(array_field_type(type_index, "array.get type"sv, false));
    if (field.type().is_packed() != requires_packed)
        return Errors::invalid("array.get signedness, present iff the element type is packed"sv);

    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(ValueType(ValueType::TypeUseReference, type_index)));
    stack.append(field.type().unpacked());
    return {};
}

VALIDATE_INSTRUCTION(array_get)
{
    return validate_array_get(stack, instruction, false);
}

VALIDATE_INSTRUCTION(array_get_s)
{
    return validate_array_get(stack, instruction, true);
}

VALIDATE_INSTRUCTION(array_get_u)
{
    return validate_array_get(stack, instruction, true);
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_set)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    auto field = TRY(array_field_type(type_index, "array.set type"sv, true));

    TRY(stack.take(field.type().unpacked()));
    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(ValueType(ValueType::TypeUseReference, type_index)));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_len)
{
    TRY(stack.take(ValueType(ValueType::ArrayReference)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_fill)
{
    auto type_index = instruction.arguments().get<TypeIndex>();
    auto field = TRY(array_field_type(type_index, "array.fill type"sv, true));

    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(field.type().unpacked()));
    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(ValueType(ValueType::TypeUseReference, type_index)));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_copy)
{
    auto& args = instruction.arguments().get<Instruction::ArrayCopyArgs>();
    auto destination_field = TRY(array_field_type(args.destination_type_index, "array.copy destination type"sv, true));
    auto source_field = TRY(array_field_type(args.source_type_index, "array.copy source type"sv, false));

    if (!matches_field_type(FieldType { false, source_field.type() }, FieldType { false, destination_field.type() }, m_context.type_context()))
        return Errors::invalid("array.copy source element type"sv, destination_field.type(), source_field.type());

    TRY((stack.take<ValueType::I32, ValueType::I32>()));
    TRY(stack.take(ValueType(ValueType::TypeUseReference, args.source_type_index)));
    TRY(stack.take<ValueType::I32>());
    TRY(stack.take(ValueType(ValueType::TypeUseReference, args.destination_type_index)));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_init_data)
{
    auto& args = instruction.arguments().get<Instruction::ArrayDataArgs>();
    auto field = TRY(array_field_type(args.type_index, "array.init_data type"sv, true));
    if (field.type().is_reference())
        return Errors::invalid("array.init_data element type"sv, "a numeric or vector type"sv, field.type());

    if (!m_context.data_count.has_value())
        return Errors::invalid("array.init_data, requires data count section"sv);
    TRY(validate(args.data_index));

    TRY((stack.take<ValueType::I32, ValueType::I32, ValueType::I32>()));
    TRY(stack.take(ValueType(ValueType::TypeUseReference, args.type_index)));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#aggregate-reference-instructions
VALIDATE_INSTRUCTION(array_init_elem)
{
    auto& args = instruction.arguments().get<Instruction::ArrayElemArgs>();
    auto field = TRY(array_field_type(args.type_index, "array.init_elem type"sv, true));
    if (!field.type().is_reference())
        return Errors::invalid("array.init_elem element type"sv, "a reference type"sv, field.type());

    TRY(validate(args.element_index));
    auto segment_type = m_context.elements[args.element_index.value()];
    if (!matches_reference_type(segment_type, field.type(), m_context.type_context()))
        return Errors::invalid("array.init_elem element segment type"sv, field.type(), segment_type);

    TRY((stack.take<ValueType::I32, ValueType::I32, ValueType::I32>()));
    TRY(stack.take(ValueType(ValueType::TypeUseReference, args.type_index)));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#reference-instructions
ErrorOr<void, ValidationError> Validator::validate_ref_test_or_cast(Stack& stack, Instruction const& instruction)
{
    auto type = instruction.arguments().get<ValueType>();
    TRY(validate(type));

    auto top = ValueType(top_of_heap_type(type, m_context.type_context()));
    TRY(stack.take(top));
    return {};
}

VALIDATE_INSTRUCTION(ref_test)
{
    TRY(validate_ref_test_or_cast(stack, instruction));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(ref_test_null)
{
    TRY(validate_ref_test_or_cast(stack, instruction));
    stack.append(ValueType(ValueType::I32));
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#reference-instructions
VALIDATE_INSTRUCTION(ref_cast)
{
    TRY(validate_ref_test_or_cast(stack, instruction));
    stack.append(instruction.arguments().get<ValueType>());
    return {};
}

VALIDATE_INSTRUCTION(ref_cast_null)
{
    TRY(validate_ref_test_or_cast(stack, instruction));
    stack.append(instruction.arguments().get<ValueType>());
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#control-instructions
ErrorOr<void, ValidationError> Validator::validate_br_on_cast(Stack& stack, Instruction const& instruction, bool branch_on_failure)
{
    auto& args = instruction.arguments().get<Instruction::BranchOnCastArgs>();
    TRY(validate(args.branch.label));
    TRY(validate(args.source_type));
    TRY(validate(args.target_type));

    if (!matches_reference_type(args.target_type, args.source_type, m_context.type_context()))
        return Errors::invalid("br_on_cast target type"sv, args.source_type, args.target_type);

    auto& target = m_frames[(m_frames.size() - 1) - args.branch.label.value()];
    auto& label_types = target.labels();
    if (label_types.is_empty() || !label_types.last().is_reference())
        return Errors::invalid("br_on_cast label type"sv, "t* rt"sv, label_types);
    auto& label_reference_type = label_types.last();

    // https://webassembly.github.io/spec/core/valid/conventions.html#conventions
    // rt1 \ rt2 = (ref ht1)        if rt2 = (ref null ht2)
    //           = (ref null1? ht1) otherwise
    auto difference = args.source_type;
    if (args.target_type.is_nullable())
        difference.set_nullable(false);

    auto& branched_type = branch_on_failure ? difference : args.target_type;
    if (!matches_reference_type(branched_type, label_reference_type, m_context.type_context()))
        return Errors::invalid("br_on_cast label type"sv, label_reference_type, branched_type);

    TRY(stack.take(args.source_type));
    for (size_t i = 0; i + 1 < label_types.size(); ++i)
        TRY(stack.take(label_types[label_types.size() - i - 2]));
    for (size_t i = 0; i + 1 < label_types.size(); ++i)
        stack.append(label_types[i]);

    stack.append(branch_on_failure ? args.target_type : difference);
    args.branch.has_stack_adjustment = target.initial_size != stack.size();
    return {};
}

VALIDATE_INSTRUCTION(br_on_cast)
{
    return validate_br_on_cast(stack, instruction, false);
}

VALIDATE_INSTRUCTION(br_on_cast_fail)
{
    return validate_br_on_cast(stack, instruction, true);
}

// https://webassembly.github.io/spec/core/valid/instructions.html#external-reference-instructions
VALIDATE_INSTRUCTION(any_convert_extern)
{
    auto entry = TRY(stack.take_last());
    bool nullable = true;
    if (entry.is_known) {
        if (!matches_value_type(entry.concrete_type, ValueType(ValueType::ExternReference), m_context.type_context()))
            return Errors::invalid("any.convert_extern operand"sv, ValueType(ValueType::ExternReference), entry);
        nullable = entry.concrete_type.is_nullable();
    } else {
        nullable = false;
    }
    stack.append(ValueType(ValueType::AnyReference, nullable));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#external-reference-instructions
VALIDATE_INSTRUCTION(extern_convert_any)
{
    auto entry = TRY(stack.take_last());
    bool nullable = true;
    if (entry.is_known) {
        if (!matches_value_type(entry.concrete_type, ValueType(ValueType::AnyReference), m_context.type_context()))
            return Errors::invalid("extern.convert_any operand"sv, ValueType(ValueType::AnyReference), entry);
        nullable = entry.concrete_type.is_nullable();
    } else {
        nullable = false;
    }
    stack.append(ValueType(ValueType::ExternReference, nullable));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#scalar-reference-instructions
VALIDATE_INSTRUCTION(ref_i31)
{
    TRY(stack.take<ValueType::I32>());
    stack.append(ValueType(ValueType::I31Reference, false));
    is_constant = true;
    return {};
}

// https://webassembly.github.io/spec/core/valid/instructions.html#scalar-reference-instructions
VALIDATE_INSTRUCTION(i31_get_s)
{
    TRY(stack.take(ValueType(ValueType::I31Reference)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(i31_get_u)
{
    TRY(stack.take(ValueType(ValueType::I31Reference)));
    stack.append(ValueType(ValueType::I32));
    return {};
}

VALIDATE_INSTRUCTION(synthetic_end_expression)
{
    is_constant = true;
    return {}; // Always valid.
}

ErrorOr<void, ValidationError> Validator::validate(Instruction const& instruction, Stack& stack, bool& is_constant)
{
    switch (instruction.opcode().value()) {
#define M(name, integer_value, ...)                                              \
    case Instructions::name.value():                                             \
        dbgln_if(WASM_VALIDATOR_DEBUG, "checking {}, stack = {}", #name, stack); \
        return validate_instruction<integer_value>(instruction, stack, is_constant);

        ENUMERATE_WASM_OPCODES(M)

#undef M
    default:
        is_constant = false;
        return Errors::invalid(ByteString::formatted("instruction opcode ({:#x})", instruction.opcode().value()));
    }
}

ErrorOr<Validator::ExpressionTypeResult, ValidationError> Validator::validate(Expression const& expression, Vector<ValueType> const& result_types)
{
    if (m_frames.is_empty())
        m_frames.empend(FunctionType { {}, result_types }, FrameKind::Function, (size_t)0);
    auto stack = Stack(m_frames, m_context.type_context());
    bool is_constant_expression = true;

    for (auto& instruction : expression.instructions()) {
        bool is_constant = false;
        TRY(validate(instruction, stack, is_constant));

        is_constant_expression &= is_constant;
    }

    auto expected_result_types = result_types;
    while (!expected_result_types.is_empty())
        TRY(stack.take(expected_result_types.take_last()));

    for (auto& type : result_types)
        stack.append(type);
    m_frames.take_last();

    expression.set_stack_usage_hint(stack.max_known_size());
    expression.set_frame_usage_hint(m_max_frame_size);

    VERIFY(m_frames.is_empty());
    m_max_frame_size = 0;

    // Now that we're in happy land, try to compile the expression down to a list of labels to help dispatch.
    expression.compiled_instructions = try_compile_instructions(expression, m_context.functions.span());

    if (expression.compiled_instructions.direct && !is_constant_expression) {
        bool has_unsupported_types = false;
        for (auto& type : m_context.locals) {
            if (type.is_reference() || type.kind() == ValueType::V128) {
                has_unsupported_types = true;
                break;
            }
        }
        if (!has_unsupported_types) {
            for (auto& type : result_types) {
                if (type.is_reference() || type.kind() == ValueType::V128) {
                    has_unsupported_types = true;
                    break;
                }
            }
        }
        // Also skip 64-bit addressing (cranelift truncates base to u32).
        if (!has_unsupported_types) {
            for (auto& mem : m_context.memories) {
                if (mem.limits().address_type() == AddressType::I64) {
                    has_unsupported_types = true;
                    break;
                }
            }
        }
        // Also skip if any call targets a function with multi-value returns.
        if (!has_unsupported_types) {
            for (auto& insn : expression.instructions()) {
                if (insn.opcode() == Instructions::call) {
                    auto func_idx = insn.arguments().get<FunctionIndex>().value();
                    if (func_idx < m_context.functions.size() && m_context.functions[func_idx].results().size() > 1) {
                        has_unsupported_types = true;
                        break;
                    }
                }
            }
        }
        // Also skip multi-value return functions.
        if (!has_unsupported_types && result_types.size() <= 1) {
            expression.compiled_instructions.cranelift_eligible = true;
            expression.compiled_instructions.cranelift_result_arity = static_cast<u32>(result_types.size());
        }
    }

    return ExpressionTypeResult { stack.release_vector(), is_constant_expression };
}

ByteString Validator::Errors::find_instruction_name(SourceLocation const& location)
{
    auto index = location.function_name().find('<');
    auto end_index = location.function_name().find('>');
    if (!index.has_value() || !end_index.has_value())
        return ByteString::formatted("{}", location);

    auto opcode = location.function_name().substring_view(index.value() + 1, end_index.value() - index.value() - 1).to_number<unsigned>();
    if (!opcode.has_value())
        return ByteString::formatted("{}", location);

    return instruction_name(OpCode { *opcode });
}

}