#pragma once

#include <wtf/Platform.h>

#if ENABLE(WEBASSEMBLY)

#include "AirArg.h"

#include "WasmOpcodeCounter.h"

#include "WasmParser.h"

#include "WasmTypeDefinitionInlines.h"

#include <wtf/DataLog.h>

#include <wtf/ListDump.h>

#include <wtf/TZoneMalloc.h>

#include <wtf/text/MakeString.h>

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

namespace JSC { namespace Wasm {

class ConstExprGenerator;

enum class BlockType {

};

enum class CatchKind {

};

OVERLOAD_RELATIONAL_OPERATORS_FOR_ENUM_CLASS_WITH_INTEGRALS(CatchKind);

template<typename EnclosingStack, typename NewStack>

void splitStack(const BlockSignature& signature, EnclosingStack& enclosingStack, NewStack& newStack)

}

struct ControlRef {

size_t m_index { 0 };

};

template<typename Control, typename Expression, typename Call>

struct FunctionParserTypes {

};

template<typename Context>

class FunctionParser : public Parser<void>, public FunctionParserTypes<typename Context::ControlType, typename Context::ExpressionType, typename Context::CallType> {

};

WTF_MAKE_TZONE_ALLOCATED_TEMPLATE_IMPL(template<typename Context>, FunctionParser<Context>);

template<typename Context>

auto FunctionParser<Context>::parseBlockSignatureAndNotifySIMDUseIfNeeded(BlockSignature& signature) -> PartialResult

{

auto result = parseBlockSignature(m_info, signature);

if (result && signature.hasReturnVector())

m_context.notifyFunctionUsesSIMD();

return result;

}

template<typename ControlType>

static bool isTryOrCatch(ControlType& data)

{

return ControlType::isTry(data) || ControlType::isCatch(data);

}

template<typename Context>

FunctionParser<Context>::FunctionParser(Context& context, std::span<const uint8_t> function, const TypeDefinition& signature, const ModuleInformation& info)

: Parser(function)

, m_context(context)

, m_signature(signature.expand())

, m_info(info)

{

if (verbose)

dataLogLn("Parsing function starting at: ", (uintptr_t)function.data(), " of length: ", function.size(), " with signature: ", signature);

m_context.setParser(this);

}

template<typename Context>

auto FunctionParser<Context>::parse() -> Result

{

uint32_t localGroupsCount;

WASM_PARSER_FAIL_IF(!m_signature->template is<FunctionSignature>(), "type signature was not a function signature"_s);

const auto& signature = *m_signature->template as<FunctionSignature>();

if (signature.numVectors() || signature.numReturnVectors())

m_context.notifyFunctionUsesSIMD();

WASM_ALLOCATOR_FAIL_IF(!m_context.addArguments(m_signature), "can't add "_s, signature.argumentCount(), " arguments to Function"_s);

WASM_PARSER_FAIL_IF(!parseVarUInt32(localGroupsCount), "can't get local groups count"_s);

WASM_ALLOCATOR_FAIL_IF(!m_locals.tryReserveCapacity(signature.argumentCount()), "can't allocate enough memory for function's "_s, signature.argumentCount(), " arguments"_s);

m_locals.appendUsingFunctor(signature.argumentCount(), [&](size_t i) {

return signature.argumentType(i);

});

uint64_t totalNumberOfLocals = signature.argumentCount();

uint64_t totalNonDefaultableLocals = 0;

for (uint32_t i = 0; i < localGroupsCount; ++i) {

uint32_t numberOfLocals;

Type typeOfLocal;

WASM_PARSER_FAIL_IF(!parseVarUInt32(numberOfLocals), "can't get Function's number of locals in group "_s, i);

totalNumberOfLocals += numberOfLocals;

WASM_PARSER_FAIL_IF(totalNumberOfLocals > maxFunctionLocals, "Function's number of locals is too big "_s, totalNumberOfLocals, " maximum "_s, maxFunctionLocals);

WASM_PARSER_FAIL_IF(!parseValueType(m_info, typeOfLocal), "can't get Function local's type in group "_s, i);

if (!isDefaultableType(typeOfLocal)) [[unlikely]]

totalNonDefaultableLocals++;

if (typeOfLocal.isV128())

m_context.notifyFunctionUsesSIMD();

WASM_ALLOCATOR_FAIL_IF(!m_locals.tryReserveCapacity(totalNumberOfLocals), "can't allocate enough memory for function's "_s, totalNumberOfLocals, " locals"_s);

m_locals.appendUsingFunctor(numberOfLocals, [&](size_t) { return typeOfLocal; });

WASM_TRY_ADD_TO_CONTEXT(addLocal(typeOfLocal, numberOfLocals));

}

WASM_ALLOCATOR_FAIL_IF(!m_localInitStack.tryReserveCapacity(totalNonDefaultableLocals), "can't allocate enough memory for tracking function's local initialization"_s);

m_localInitFlags.ensureSize(totalNumberOfLocals);

// Param locals are always considered initialized, so we need to pre-set them.

for (uint32_t i = 0; i < signature.argumentCount(); ++i) {

if (!isDefaultableType(signature.argumentType(i)))

m_localInitFlags.quickSet(i);

}

m_context.didFinishParsingLocals();

WASM_FAIL_IF_HELPER_FAILS(parseBody());

return { };

}

template<typename Context>

auto FunctionParser<Context>::parseConstantExpression() -> Result

{

WASM_PARSER_FAIL_IF(!m_signature->template is<FunctionSignature>(), "type signature was not a function signature"_s);

const auto& signature = *m_signature->template as<FunctionSignature>();

if (signature.numVectors() || signature.numReturnVectors())

m_context.notifyFunctionUsesSIMD();

ASSERT(!signature.argumentCount());

WASM_FAIL_IF_HELPER_FAILS(parseBody());

return { };

}

template<typename Context>

auto FunctionParser<Context>::parseBody() -> PartialResult

{

const auto& functionSignature = *m_signature->template as<FunctionSignature>();

m_controlStack.append({ { }, { }, 0, m_context.addTopLevel(BlockSignature { functionSignature }) });

uint8_t op = 0;

while (m_controlStack.size()) {

m_currentOpcodeStartingOffset = m_offset;

WASM_PARSER_FAIL_IF(!parseUInt8(op), "can't decode opcode"_s);

WASM_PARSER_FAIL_IF(!isValidOpType(op), "invalid opcode "_s, op);

m_currentOpcode = static_cast<OpType>(op);

#if ENABLE(WEBASSEMBLY_OMGJIT)

if (Options::dumpWasmOpcodeStatistics()) [[unlikely]]

WasmOpcodeCounter::singleton().increment(m_currentOpcode);

#endif

if constexpr (verbose) {

String extOpString;

auto computeExtOpString = [&]<typename ExtOpEnum>() {

uint32_t extOpBits;

if (peekVarUInt32(extOpBits))

extOpString = makeString("::"_s, makeString(static_cast<ExtOpEnum>(extOpBits)));

else

extOpString = makeString(" with invalid extension: "_s, extOpBits);

};

#define HANDLE_EXT_OP_PREFIX(name, id, b3, hasExtra, ExtOpEnumType) \

if (m_currentOpcode == OpType::name) \

computeExtOpString.template operator()<ExtOpEnumType>();

FOR_EACH_WASM_EXT_PREFIX_OP_WITH_ENUM(HANDLE_EXT_OP_PREFIX)

#undef HANDLE_EXT_OP_PREFIX

dataLogLn("processing op (", m_unreachableBlocks, "): ", RawHex(m_currentOpcode), ", ", makeString(static_cast<OpType>(m_currentOpcode)), extOpString, " at offset: ", RawHex(m_currentOpcodeStartingOffset));

m_context.dump(m_controlStack, &m_expressionStack);

}

m_context.willParseOpcode();

if (m_unreachableBlocks)

WASM_FAIL_IF_HELPER_FAILS(parseUnreachableExpression());

else

WASM_FAIL_IF_HELPER_FAILS(parseExpression());

m_context.didParseOpcode();

}

WASM_FAIL_IF_HELPER_FAILS(m_context.endTopLevel(m_expressionStack));

if (Context::validateFunctionBodySize)

WASM_PARSER_FAIL_IF(m_offset != source().size(), "function body size doesn't match the expected size");

ASSERT(op == OpType::End);

return { };

}

template<typename Context>

auto FunctionParser<Context>::binaryCase(OpType op, BinaryOperationHandler handler, Type returnType, Type lhsType, Type rhsType) -> PartialResult

{

TypedExpression right;

TypedExpression left;

WASM_TRY_POP_EXPRESSION_STACK_INTO(right, "binary right"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(left, "binary left"_s);

WASM_VALIDATOR_FAIL_IF(left.type() != lhsType, op, " left value type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(right.type() != rhsType, op, " right value type mismatch"_s);

ExpressionType result;

WASM_FAIL_IF_HELPER_FAILS((m_context.*handler)(left, right, result));

m_expressionStack.constructAndAppend(returnType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::binaryCompareCase(OpType op, BinaryOperationHandler handler, Type returnType, Type lhsType, Type rhsType) -> PartialResult

{

TypedExpression right;

TypedExpression left;

WASM_TRY_POP_EXPRESSION_STACK_INTO(right, "binary right"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(left, "binary left"_s);

WASM_VALIDATOR_FAIL_IF(left.type() != lhsType, op, " left value type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(right.type() != rhsType, op, " right value type mismatch"_s);

uint8_t nextOpcode;

if (Context::shouldFuseBranchCompare && peekUInt8(nextOpcode)) {

if (nextOpcode == OpType::BrIf) {

m_currentOpcodeStartingOffset = m_offset;

m_currentOpcode = static_cast<OpType>(nextOpcode);

bool didParseNextOpcode = parseUInt8(nextOpcode); // We're going to fuse this compare to the branch, so we consume the opcode.

ASSERT_UNUSED(didParseNextOpcode, didParseNextOpcode);

m_context.willParseOpcode();

uint32_t target;

WASM_FAIL_IF_HELPER_FAILS(parseBranchTarget(target));

ControlType& data = m_controlStack[m_controlStack.size() - 1 - target].controlData;

WASM_FAIL_IF_HELPER_FAILS(checkBranchTarget(data, Conditional));

WASM_TRY_ADD_TO_CONTEXT(addFusedBranchCompare(op, data, left, right, m_expressionStack));

m_context.didParseOpcode();

return { };

}

if (nextOpcode == OpType::If) {

m_currentOpcodeStartingOffset = m_offset;

m_currentOpcode = static_cast<OpType>(nextOpcode);

bool didParseNextOpcode = parseUInt8(nextOpcode); // We're going to fuse this compare to the branch, so we consume the opcode.

ASSERT_UNUSED(didParseNextOpcode, didParseNextOpcode);

m_context.willParseOpcode();

BlockSignature inlineSignature;

WASM_PARSER_FAIL_IF(!parseBlockSignatureAndNotifySIMDUseIfNeeded(inlineSignature), "can't get if's signature"_s);

WASM_VALIDATOR_FAIL_IF(m_expressionStack.size() < inlineSignature.argumentCount(), "Too few arguments on stack for if block. If expects ", inlineSignature.argumentCount(), ", but only ", m_expressionStack.size(), " were present. If block has signature: ", inlineSignature);

unsigned offset = m_expressionStack.size() - inlineSignature.argumentCount();

for (unsigned i = 0; i < inlineSignature.argumentCount(); ++i)

WASM_VALIDATOR_FAIL_IF(!isSubtype(m_expressionStack[offset + i].type(), inlineSignature.argumentType(i)), "Loop expects the argument at index", i, " to be ", inlineSignature.argumentType(i), " but argument has type ", m_expressionStack[i].type());

int64_t oldSize = m_expressionStack.size();

Stack newStack;

ControlType control;

WASM_TRY_ADD_TO_CONTEXT(addFusedIfCompare(op, left, right, WTF::move(inlineSignature), m_expressionStack, control, newStack));

ASSERT_UNUSED(oldSize, oldSize - m_expressionStack.size() == control.signature().argumentCount());

ASSERT(newStack.size() == control.signature().argumentCount());

m_controlStack.append({ WTF::move(m_expressionStack), newStack, getLocalInitStackHeight(), WTF::move(control) });

m_expressionStack = WTF::move(newStack);

m_context.didParseOpcode();

return { };

}

}

ExpressionType result;

WASM_FAIL_IF_HELPER_FAILS((m_context.*handler)(left, right, result));

m_expressionStack.constructAndAppend(returnType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::unaryCase(OpType op, UnaryOperationHandler handler, Type returnType, Type operandType) -> PartialResult

{

TypedExpression value;

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "unary"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != operandType, op, " value type mismatch"_s);

ExpressionType result;

WASM_FAIL_IF_HELPER_FAILS((m_context.*handler)(value, result));

m_expressionStack.constructAndAppend(returnType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::unaryCompareCase(OpType op, UnaryOperationHandler handler, Type returnType, Type operandType) -> PartialResult

{

TypedExpression value;

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "unary"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != operandType, op, " value type mismatch"_s);

uint8_t nextOpcode;

if (Context::shouldFuseBranchCompare && peekUInt8(nextOpcode)) {

if (nextOpcode == OpType::BrIf) {

bool didParseNextOpcode = parseUInt8(nextOpcode); // We're going to fuse this compare to the branch, so we consume the opcode.

ASSERT_UNUSED(didParseNextOpcode, didParseNextOpcode);

uint32_t target;

WASM_FAIL_IF_HELPER_FAILS(parseBranchTarget(target));

ControlType& data = m_controlStack[m_controlStack.size() - 1 - target].controlData;

WASM_FAIL_IF_HELPER_FAILS(checkBranchTarget(data, Conditional));

WASM_TRY_ADD_TO_CONTEXT(addFusedBranchCompare(op, data, value, m_expressionStack));

return { };

}

if (nextOpcode == OpType::If) {

bool didParseNextOpcode = parseUInt8(nextOpcode); // We're going to fuse this compare to the if, so we consume the opcode.

ASSERT_UNUSED(didParseNextOpcode, didParseNextOpcode);

BlockSignature inlineSignature;

WASM_PARSER_FAIL_IF(!parseBlockSignatureAndNotifySIMDUseIfNeeded(inlineSignature), "can't get if's signature"_s);

WASM_VALIDATOR_FAIL_IF(m_expressionStack.size() < inlineSignature.argumentCount(), "Too few arguments on stack for if block. If expects ", inlineSignature.argumentCount(), ", but only ", m_expressionStack.size(), " were present. If block has signature: ", inlineSignature);

unsigned offset = m_expressionStack.size() - inlineSignature.argumentCount();

for (unsigned i = 0; i < inlineSignature.argumentCount(); ++i)

WASM_VALIDATOR_FAIL_IF(!isSubtype(m_expressionStack[offset + i].type(), inlineSignature.argumentType(i)), "Loop expects the argument at index", i, " to be ", inlineSignature.argumentType(i), " but argument has type ", m_expressionStack[i].type());

int64_t oldSize = m_expressionStack.size();

Stack newStack;

ControlType control;

WASM_TRY_ADD_TO_CONTEXT(addFusedIfCompare(op, value, WTF::move(inlineSignature), m_expressionStack, control, newStack));

ASSERT_UNUSED(oldSize, oldSize - m_expressionStack.size() == control.signature().argumentCount());

ASSERT(newStack.size() == control.signature().argumentCount());

m_controlStack.append({ WTF::move(m_expressionStack), newStack, getLocalInitStackHeight(), WTF::move(control) });

m_expressionStack = WTF::move(newStack);

return { };

}

}

ExpressionType result;

WASM_FAIL_IF_HELPER_FAILS((m_context.*handler)(value, result));

m_expressionStack.constructAndAppend(returnType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::load(Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "load instruction without memory"_s);

uint32_t alignment;

uint64_t offset;

TypedExpression pointer;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment"_s);

bool hasMemoryIndex = alignment & (1 << 6);

alignment = alignment & 0b111111;

WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(m_currentOpcode), "byte alignment "_s, 1ull << alignment, " exceeds load's natural alignment "_s, 1ull << memoryLog2Alignment(m_currentOpcode));

uint32_t memoryIndex = 0;

if (hasMemoryIndex) {

WASM_PARSER_FAIL_IF(!parseVarUInt32(memoryIndex), "can't get memory index"_s);

RELEASE_ASSERT(memoryIndex < 256);

WASM_VALIDATOR_FAIL_IF(memoryIndex >= m_info.memoryCount(), "memory index "_s, memoryIndex, " is out of range"_s);

}

if (m_info.memory(memoryIndex).isMemory64())

WASM_PARSER_FAIL_IF(!parseVarUInt64(offset), "can't get load offset"_s);

else {

uint32_t offset32;

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset32), "can't get load offset"_s);

offset = offset32;

}

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "load pointer"_s);

if (m_info.memory(memoryIndex).isMemory64())

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI64(), m_currentOpcode, " pointer type mismatch"_s);

else

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), m_currentOpcode, " pointer type mismatch"_s);

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(load(static_cast<LoadOpType>(m_currentOpcode), pointer, result, offset, static_cast<uint8_t>(memoryIndex)));

m_expressionStack.constructAndAppend(memoryType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::store(Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "store instruction without memory"_s);

uint32_t alignment;

uint64_t offset;

TypedExpression value;

TypedExpression pointer;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get store alignment"_s);

bool hasMemoryIndex = alignment & (1 << 6);

alignment = alignment & 0b111111;

WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(m_currentOpcode), "byte alignment "_s, 1ull << alignment, " exceeds store's natural alignment "_s, 1ull << memoryLog2Alignment(m_currentOpcode));

uint32_t memoryIndex = 0;

if (hasMemoryIndex) {

WASM_PARSER_FAIL_IF(!parseVarUInt32(memoryIndex), "can't get memory index"_s);

RELEASE_ASSERT(memoryIndex < 256);

WASM_VALIDATOR_FAIL_IF(memoryIndex >= m_info.memoryCount(), "memory index "_s, memoryIndex, " is out of range"_s);

}

if (m_info.memory(memoryIndex).isMemory64())

WASM_PARSER_FAIL_IF(!parseVarUInt64(offset), "can't get store offset"_s);

else {

uint32_t offset32;

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset32), "can't get store offset"_s);

offset = offset32;

}

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "store value"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "store pointer"_s);

if (m_info.memory(memoryIndex).isMemory64())

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI64(), m_currentOpcode, " pointer type mismatch"_s);

else

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), m_currentOpcode, " pointer type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, m_currentOpcode, " value type mismatch"_s);

WASM_TRY_ADD_TO_CONTEXT(store(static_cast<StoreOpType>(m_currentOpcode), pointer, value, offset, static_cast<uint8_t>(memoryIndex)));

return { };

}

template<typename Context>

auto FunctionParser<Context>::truncSaturated(Ext1OpType op, Type returnType, Type operandType) -> PartialResult

{

TypedExpression value;

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "unary"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != operandType, "trunc-saturated value type mismatch. Expected: "_s, operandType, " but expression stack has "_s, value.type());

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(truncSaturated(op, value, result, returnType, operandType));

m_expressionStack.constructAndAppend(returnType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicLoad(ExtAtomicOpType op, Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "atomic instruction without memory"_s);

uint32_t alignment;

uint32_t offset;

TypedExpression pointer;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment"_s);

WASM_PARSER_FAIL_IF(alignment != memoryLog2Alignment(op), "byte alignment "_s, 1ull << alignment, " does not match against atomic op's natural alignment "_s, 1ull << memoryLog2Alignment(op));

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "load pointer"_s);

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch"_s);

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(atomicLoad(op, memoryType, pointer, result, offset));

m_expressionStack.constructAndAppend(memoryType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicStore(ExtAtomicOpType op, Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "atomic instruction without memory"_s);

uint32_t alignment;

uint32_t offset;

TypedExpression value;

TypedExpression pointer;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get store alignment"_s);

WASM_PARSER_FAIL_IF(alignment != memoryLog2Alignment(op), "byte alignment "_s, 1ull << alignment, " does not match against atomic op's natural alignment "_s, 1ull << memoryLog2Alignment(op));

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get store offset"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "store value"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "store pointer"_s);

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), m_currentOpcode, " pointer type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, m_currentOpcode, " value type mismatch"_s);

WASM_TRY_ADD_TO_CONTEXT(atomicStore(op, memoryType, pointer, value, offset));

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicBinaryRMW(ExtAtomicOpType op, Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "atomic instruction without memory"_s);

uint32_t alignment;

uint32_t offset;

TypedExpression pointer;

TypedExpression value;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment"_s);

WASM_PARSER_FAIL_IF(alignment != memoryLog2Alignment(op), "byte alignment "_s, 1ull << alignment, " does not match against atomic op's natural alignment "_s, 1ull << memoryLog2Alignment(op));

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "value"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer"_s);

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch"_s);

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(atomicBinaryRMW(op, memoryType, pointer, value, result, offset));

m_expressionStack.constructAndAppend(memoryType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicCompareExchange(ExtAtomicOpType op, Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "atomic instruction without memory"_s);

uint32_t alignment;

uint32_t offset;

TypedExpression pointer;

TypedExpression expected;

TypedExpression value;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment"_s);

WASM_PARSER_FAIL_IF(alignment != memoryLog2Alignment(op), "byte alignment "_s, 1ull << alignment, " does not match against atomic op's natural alignment "_s, 1ull << memoryLog2Alignment(op));

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "value"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(expected, "expected"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer"_s);

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(expected.type() != memoryType, static_cast<unsigned>(op), " expected type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch"_s);

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(atomicCompareExchange(op, memoryType, pointer, expected, value, result, offset));

m_expressionStack.constructAndAppend(memoryType, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicWait(ExtAtomicOpType op, Type memoryType) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "atomic instruction without memory"_s);

uint32_t alignment;

uint32_t offset;

TypedExpression pointer;

TypedExpression value;

TypedExpression timeout;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment"_s);

WASM_PARSER_FAIL_IF(alignment != memoryLog2Alignment(op), "byte alignment "_s, 1ull << alignment, " does not match against atomic op's natural alignment "_s, 1ull << memoryLog2Alignment(op));

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(timeout, "timeout"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "value"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer"_s);

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(!timeout.type().isI64(), static_cast<unsigned>(op), " timeout type mismatch"_s);

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(atomicWait(op, pointer, value, timeout, result, offset));

m_expressionStack.constructAndAppend(Types::I32, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicNotify(ExtAtomicOpType op) -> PartialResult

{

WASM_VALIDATOR_FAIL_IF(!m_info.memoryCount(), "atomic instruction without memory"_s);

uint32_t alignment;

uint32_t offset;

TypedExpression pointer;

TypedExpression count;

WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment"_s);

WASM_PARSER_FAIL_IF(alignment != memoryLog2Alignment(op), "byte alignment "_s, 1ull << alignment, " does not match against atomic op's natural alignment "_s, 1ull << memoryLog2Alignment(op));

WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(count, "count"_s);

WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer"_s);

WASM_VALIDATOR_FAIL_IF(!pointer.type().isI32(), static_cast<unsigned>(op), " pointer type mismatch"_s);

WASM_VALIDATOR_FAIL_IF(!count.type().isI32(), static_cast<unsigned>(op), " count type mismatch"_s); // The spec's definition is saying i64, but all implementations (including tests) are using i32. So looks like the spec is wrong.

ExpressionType result;

WASM_TRY_ADD_TO_CONTEXT(atomicNotify(op, pointer, count, result, offset));

m_expressionStack.constructAndAppend(Types::I32, result);

return { };

}

template<typename Context>

auto FunctionParser<Context>::atomicFence(ExtAtomicOpType op) -> PartialResult

{

uint8_t flags;

WASM_PARSER_FAIL_IF(!parseUInt8(flags), "can't get flags"_s);

WASM_PARSER_FAIL_IF(flags != 0x0, "flags should be 0x0 but got "_s, flags);

WASM_TRY_ADD_TO_CONTEXT(atomicFence(op, flags));

return { };

}

#if ENABLE(B3_JIT)

template<typename Context>

template<bool isReachable, typename>

auto FunctionParser<Context>::simd(SIMDLaneOperation op, SIMDLane lane, SIMDSignMode signMode, B3::Air::Arg optionalRelation) -> PartialResult

{

UNUSED_PARAM(signMode);

m_context.notifyFunctionUsesSIMD();

auto pushUnreachable = [&](auto type) -> PartialResult {

ASSERT(isReachable);

// Appease generators without SIMD support.

m_expressionStack.constructAndAppend(type, m_context.addConstant(Types::F64, 0));

return { };

};

// only used in some specializations

UNUSED_VARIABLE(pushUnreachable);

UNUSED_PARAM(optionalRelation);

auto parseMemOp = [&] (uint32_t& offset, TypedExpression& pointer) -> PartialResult {

uint32_t maxAlignment;

switch (op) {

case SIMDLaneOperation::LoadLane8:

case SIMDLaneOperation::StoreLane8:

case SIMDLaneOperation::LoadSplat8:

maxAlignment = 0;

break;

case SIMDLaneOperation::LoadLane16:

case SIMDLaneOperation::StoreLane16:

case SIMDLaneOperation::LoadSplat16:

maxAlignment = 1;

break;

case SIMDLaneOperation::LoadLane32:

case SIMDLaneOperation::StoreLane32:

case SIMDLaneOperation::LoadSplat32:

case SIMDLaneOperation::LoadPad32:

maxAlignment = 2;

break;

case SIMDLaneOperation::LoadLane64:

case SIMDLaneOperation::StoreLane64:

case SIMDLaneOperation::LoadSplat64:

case SIMDLaneOperation::LoadPad64:

case SIMDLaneOperation::LoadExtend8U: