/*
 * Copyright (C) 2015 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "WASMFunctionParser.h"

#if ENABLE(WEBASSEMBLY)

#include "JSCJSValueInlines.h"
#include "JSWASMModule.h"
#include "WASMFunctionCompiler.h"
#include "WASMFunctionLLVMIRGenerator.h"
#include "WASMFunctionSyntaxChecker.h"

#define PROPAGATE_ERROR() do { if (!m_errorMessage.isNull()) return 0; } while (0)
#define FAIL_WITH_MESSAGE(errorMessage) do {  m_errorMessage = errorMessage; return 0; } while (0)
#define READ_FLOAT_OR_FAIL(result, errorMessage) do { if (!m_reader.readFloat(result)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_DOUBLE_OR_FAIL(result, errorMessage) do { if (!m_reader.readDouble(result)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_COMPACT_INT32_OR_FAIL(result, errorMessage) do { if (!m_reader.readCompactInt32(result)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_COMPACT_UINT32_OR_FAIL(result, errorMessage) do { if (!m_reader.readCompactUInt32(result)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_EXPRESSION_TYPE_OR_FAIL(result, errorMessage) do { if (!m_reader.readExpressionType(result)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_OP_STATEMENT_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, errorMessage) do { if (!m_reader.readOpStatement(hasImmediate, op, opWithImmediate, immediate)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_OP_EXPRESSION_I32_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, errorMessage) do { if (!m_reader.readOpExpressionI32(hasImmediate, op, opWithImmediate, immediate)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_OP_EXPRESSION_F32_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, errorMessage) do { if (!m_reader.readOpExpressionF32(hasImmediate, op, opWithImmediate, immediate)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_OP_EXPRESSION_F64_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, errorMessage) do { if (!m_reader.readOpExpressionF64(hasImmediate, op, opWithImmediate, immediate)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_OP_EXPRESSION_VOID_OR_FAIL(op, errorMessage) do { if (!m_reader.readOpExpressionVoid(op)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_VARIABLE_TYPES_OR_FAIL(hasImmediate, variableTypes, variableTypesWithImmediate, immediate, errorMessage) do { if (!m_reader.readVariableTypes(hasImmediate, variableTypes, variableTypesWithImmediate, immediate)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define READ_SWITCH_CASE_OR_FAIL(result, errorMessage) do { if (!m_reader.readSwitchCase(result)) FAIL_WITH_MESSAGE(errorMessage); } while (0)
#define FAIL_IF_FALSE(condition, errorMessage) do { if (!(condition)) FAIL_WITH_MESSAGE(errorMessage); } while (0)

#define UNUSED 0

namespace JSC {

static String nameOfType(WASMType type)
{
    switch (type) {
    case WASMType::I32:
        return "int32";
    case WASMType::F32:
        return "float32";
    case WASMType::F64:
        return "float64";
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

bool WASMFunctionParser::checkSyntax(JSWASMModule* module, const SourceCode& source, size_t functionIndex, unsigned startOffsetInSource, unsigned& endOffsetInSource, unsigned& stackHeight, String& errorMessage)
{
    WASMFunctionParser parser(module, source, functionIndex);
    WASMFunctionSyntaxChecker syntaxChecker;
    parser.m_reader.setOffset(startOffsetInSource);
    parser.parseFunction(syntaxChecker);
    if (!parser.m_errorMessage.isNull()) {
        errorMessage = parser.m_errorMessage;
        return false;
    }
    endOffsetInSource = parser.m_reader.offset();
    stackHeight = syntaxChecker.stackHeight();
    return true;
}

void WASMFunctionParser::compile(VM& vm, CodeBlock* codeBlock, JSWASMModule* module, const SourceCode& source, size_t functionIndex)
{
    WASMFunctionParser parser(module, source, functionIndex);
    WASMFunctionCompiler compiler(vm, codeBlock, module, module->functionStackHeights()[functionIndex]);
    parser.m_reader.setOffset(module->functionStartOffsetsInSource()[functionIndex]);
    parser.parseFunction(compiler);
    ASSERT(parser.m_errorMessage.isNull());
}

template <class Context>
bool WASMFunctionParser::parseFunction(Context& context)
{
    const WASMSignature& signature = m_module->signatures()[m_module->functionDeclarations()[m_functionIndex].signatureIndex];

    m_returnType = signature.returnType;

    parseLocalVariables();
    PROPAGATE_ERROR();

    const Vector<WASMType>& arguments = signature.arguments;
    for (size_t i = 0; i < arguments.size(); ++i)
        m_localTypes.append(arguments[i]);
    for (uint32_t i = 0; i < m_numberOfI32LocalVariables; ++i)
        m_localTypes.append(WASMType::I32);
    for (uint32_t i = 0; i < m_numberOfF32LocalVariables; ++i)
        m_localTypes.append(WASMType::F32);
    for (uint32_t i = 0; i < m_numberOfF64LocalVariables; ++i)
        m_localTypes.append(WASMType::F64);

    context.startFunction(arguments, m_numberOfI32LocalVariables, m_numberOfF32LocalVariables, m_numberOfF64LocalVariables);

    parseBlockStatement(context);
    PROPAGATE_ERROR();

    context.endFunction();
    return true;
}

bool WASMFunctionParser::parseLocalVariables()
{
    m_numberOfI32LocalVariables = 0;
    m_numberOfF32LocalVariables = 0;
    m_numberOfF64LocalVariables = 0;

    bool hasImmediate;
    WASMVariableTypes variableTypes;
    WASMVariableTypesWithImmediate variableTypesWithImmediate;
    uint8_t immediate;
    READ_VARIABLE_TYPES_OR_FAIL(hasImmediate, variableTypes, variableTypesWithImmediate, immediate, "Cannot read the types of local variables.");
    if (!hasImmediate) {
        if (static_cast<uint8_t>(variableTypes) & static_cast<uint8_t>(WASMVariableTypes::I32))
            READ_COMPACT_UINT32_OR_FAIL(m_numberOfI32LocalVariables, "Cannot read the number of int32 local variables.");
        if (static_cast<uint8_t>(variableTypes) & static_cast<uint8_t>(WASMVariableTypes::F32))
            READ_COMPACT_UINT32_OR_FAIL(m_numberOfF32LocalVariables, "Cannot read the number of float32 local variables.");
        if (static_cast<uint8_t>(variableTypes) & static_cast<uint8_t>(WASMVariableTypes::F64))
            READ_COMPACT_UINT32_OR_FAIL(m_numberOfF64LocalVariables, "Cannot read the number of float64 local variables.");
    } else
        m_numberOfI32LocalVariables = immediate;
    return true;
}

template <class Context>
ContextStatement WASMFunctionParser::parseStatement(Context& context)
{
    bool hasImmediate;
    WASMOpStatement op;
    WASMOpStatementWithImmediate opWithImmediate;
    uint8_t immediate;
    READ_OP_STATEMENT_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, "Cannot read the statement opcode.");
    if (!hasImmediate) {
        switch (op) {
        case WASMOpStatement::SetLocal:
            parseSetLocal(context, WASMOpKind::Statement, WASMExpressionType::Void);
            break;
        case WASMOpStatement::SetGlobal:
            parseSetGlobal(context, WASMOpKind::Statement, WASMExpressionType::Void);
            break;
        case WASMOpStatement::I32Store8:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::NoOffset);
            break;
        case WASMOpStatement::I32StoreWithOffset8:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::WithOffset);
            break;
        case WASMOpStatement::I32Store16:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::NoOffset);
            break;
        case WASMOpStatement::I32StoreWithOffset16:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::WithOffset);
            break;
        case WASMOpStatement::I32Store32:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::I32, WASMMemoryType::I32, MemoryAccessOffsetMode::NoOffset);
            break;
        case WASMOpStatement::I32StoreWithOffset32:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::I32, WASMMemoryType::I32, MemoryAccessOffsetMode::WithOffset);
            break;
        case WASMOpStatement::F32Store:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::F32, WASMMemoryType::F32, MemoryAccessOffsetMode::NoOffset);
            break;
        case WASMOpStatement::F32StoreWithOffset:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::F32, WASMMemoryType::F32, MemoryAccessOffsetMode::WithOffset);
            break;
        case WASMOpStatement::F64Store:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::F64, WASMMemoryType::F64, MemoryAccessOffsetMode::NoOffset);
            break;
        case WASMOpStatement::F64StoreWithOffset:
            parseStore(context, WASMOpKind::Statement, WASMExpressionType::F64, WASMMemoryType::F64, MemoryAccessOffsetMode::WithOffset);
            break;
        case WASMOpStatement::CallInternal:
            parseCallInternal(context, WASMOpKind::Statement, WASMExpressionType::Void);
            break;
        case WASMOpStatement::CallIndirect:
            parseCallIndirect(context, WASMOpKind::Statement, WASMExpressionType::Void);
            break;
        case WASMOpStatement::CallImport:
            parseCallImport(context, WASMOpKind::Statement, WASMExpressionType::Void);
            break;
        case WASMOpStatement::Return:
            parseReturnStatement(context);
            break;
        case WASMOpStatement::Block:
            parseBlockStatement(context);
            break;
        case WASMOpStatement::If:
            parseIfStatement(context);
            break;
        case WASMOpStatement::IfElse:
            parseIfElseStatement(context);
            break;
        case WASMOpStatement::While:
            parseWhileStatement(context);
            break;
        case WASMOpStatement::Do:
            parseDoStatement(context);
            break;
        case WASMOpStatement::Label:
            parseLabelStatement(context);
            break;
        case WASMOpStatement::Break:
            parseBreakStatement(context);
            break;
        case WASMOpStatement::BreakLabel:
            parseBreakLabelStatement(context);
            break;
        case WASMOpStatement::Continue:
            parseContinueStatement(context);
            break;
        case WASMOpStatement::ContinueLabel:
            parseContinueLabelStatement(context);
            break;
        case WASMOpStatement::Switch:
            parseSwitchStatement(context);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
    } else {
        switch (opWithImmediate) {
        case WASMOpStatementWithImmediate::SetLocal:
            parseSetLocal(context, WASMOpKind::Statement, WASMExpressionType::Void, immediate);
            break;
        case WASMOpStatementWithImmediate::SetGlobal:
            parseSetGlobal(context, WASMOpKind::Statement, WASMExpressionType::Void, immediate);
            break;
        default:
            ASSERT_NOT_REACHED();
        }
    }
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseReturnStatement(Context& context)
{
    ContextExpression expression = 0;
    if (m_returnType != WASMExpressionType::Void) {
        expression = parseExpression(context, m_returnType);
        PROPAGATE_ERROR();
    }
    context.buildReturn(expression, m_returnType);
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseBlockStatement(Context& context)
{
    uint32_t numberOfStatements;
    READ_COMPACT_UINT32_OR_FAIL(numberOfStatements, "Cannot read the number of statements.");
    for (uint32_t i = 0; i < numberOfStatements; ++i) {
        parseStatement(context);
        PROPAGATE_ERROR();
    }
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseIfStatement(Context& context)
{
    ContextJumpTarget end;

    ContextExpression expression = parseExpressionI32(context);
    PROPAGATE_ERROR();

    context.jumpToTargetIf(Context::JumpCondition::Zero, expression, end);

    parseStatement(context);
    PROPAGATE_ERROR();

    context.linkTarget(end);
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseIfElseStatement(Context& context)
{
    ContextJumpTarget elseTarget;
    ContextJumpTarget end;

    ContextExpression expression = parseExpressionI32(context);
    PROPAGATE_ERROR();

    context.jumpToTargetIf(Context::JumpCondition::Zero, expression, elseTarget);

    parseStatement(context);
    PROPAGATE_ERROR();

    context.jumpToTarget(end);
    context.linkTarget(elseTarget);

    parseStatement(context);
    PROPAGATE_ERROR();

    context.linkTarget(end);
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseWhileStatement(Context& context)
{
    context.startLoop();
    context.linkTarget(context.continueTarget());

    ContextExpression expression = parseExpressionI32(context);
    PROPAGATE_ERROR();

    context.jumpToTargetIf(Context::JumpCondition::Zero, expression, context.breakTarget());

    m_breakScopeDepth++;
    m_continueScopeDepth++;
    parseStatement(context);
    PROPAGATE_ERROR();
    m_continueScopeDepth--;
    m_breakScopeDepth--;

    context.jumpToTarget(context.continueTarget());

    context.linkTarget(context.breakTarget());
    context.endLoop();
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseDoStatement(Context& context)
{
    context.startLoop();

    ContextJumpTarget topOfLoop;
    context.linkTarget(topOfLoop);

    m_breakScopeDepth++;
    m_continueScopeDepth++;
    parseStatement(context);
    PROPAGATE_ERROR();
    m_continueScopeDepth--;
    m_breakScopeDepth--;

    context.linkTarget(context.continueTarget());

    ContextExpression expression = parseExpressionI32(context);
    PROPAGATE_ERROR();

    context.jumpToTargetIf(Context::JumpCondition::NonZero, expression, topOfLoop);

    context.linkTarget(context.breakTarget());
    context.endLoop();
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseLabelStatement(Context& context)
{
    context.startLabel();
    m_labelDepth++;
    parseStatement(context);
    PROPAGATE_ERROR();
    m_labelDepth--;
    context.endLabel();
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseBreakStatement(Context& context)
{
    FAIL_IF_FALSE(m_breakScopeDepth, "'break' is only valid inside a switch or loop statement.");
    context.jumpToTarget(context.breakTarget());
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseBreakLabelStatement(Context& context)
{
    uint32_t labelIndex;
    READ_COMPACT_UINT32_OR_FAIL(labelIndex, "Cannot read the label index.");
    FAIL_IF_FALSE(labelIndex < m_labelDepth, "The label index is incorrect.");
    context.jumpToTarget(context.breakLabelTarget(labelIndex));
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseContinueStatement(Context& context)
{
    FAIL_IF_FALSE(m_continueScopeDepth, "'continue' is only valid inside a loop statement.");
    context.jumpToTarget(context.continueTarget());
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseContinueLabelStatement(Context& context)
{
    uint32_t labelIndex;
    READ_COMPACT_UINT32_OR_FAIL(labelIndex, "Cannot read the label index.");
    FAIL_IF_FALSE(labelIndex < m_labelDepth, "The label index is incorrect.");
    context.jumpToTarget(context.continueLabelTarget(labelIndex));
    return UNUSED;
}

template <class Context>
ContextStatement WASMFunctionParser::parseSwitchStatement(Context& context)
{
    context.startSwitch();
    uint32_t numberOfCases;
    READ_COMPACT_UINT32_OR_FAIL(numberOfCases, "Cannot read the number of cases.");
    ContextExpression expression = parseExpressionI32(context);
    PROPAGATE_ERROR();

    ContextJumpTarget compare;
    context.jumpToTarget(compare);

    Vector<int64_t> cases;
    Vector<ContextJumpTarget> targets;
    cases.reserveInitialCapacity(numberOfCases);
    targets.reserveInitialCapacity(numberOfCases);
    bool hasDefault = false;
    ContextJumpTarget defaultTarget;

    m_breakScopeDepth++;
    for (uint32_t i = 0; i < numberOfCases; ++i) {
        WASMSwitchCase switchCase;
        READ_SWITCH_CASE_OR_FAIL(switchCase, "Cannot read the switch case.");
        switch (switchCase) {
        case WASMSwitchCase::CaseWithNoStatements:
        case WASMSwitchCase::CaseWithStatement:
        case WASMSwitchCase::CaseWithBlockStatement: {
            uint32_t value;
            READ_COMPACT_INT32_OR_FAIL(value, "Cannot read the value of the switch case.");
            cases.uncheckedAppend(value);
            ContextJumpTarget target;
            context.linkTarget(target);
            targets.uncheckedAppend(target);
            if (switchCase == WASMSwitchCase::CaseWithStatement) {
                parseStatement(context);
                PROPAGATE_ERROR();
            } else if (switchCase == WASMSwitchCase::CaseWithBlockStatement) {
                parseBlockStatement(context);
                PROPAGATE_ERROR();
            }
            break;
        }
        case WASMSwitchCase::DefaultWithNoStatements:
        case WASMSwitchCase::DefaultWithStatement:
        case WASMSwitchCase::DefaultWithBlockStatement: {
            FAIL_IF_FALSE(i == numberOfCases - 1, "The default case must be the last case.");
            hasDefault = true;
            context.linkTarget(defaultTarget);
            if (switchCase == WASMSwitchCase::DefaultWithStatement) {
                parseStatement(context);
                PROPAGATE_ERROR();
            } else if (switchCase == WASMSwitchCase::DefaultWithBlockStatement) {
                parseBlockStatement(context);
                PROPAGATE_ERROR();
            }
            break;
        }
        default:
            ASSERT_NOT_REACHED();
        }
    }
    if (!hasDefault)
        context.linkTarget(defaultTarget);

    m_breakScopeDepth--;

    context.jumpToTarget(context.breakTarget());
    context.linkTarget(compare);

    context.buildSwitch(expression, cases, targets, defaultTarget);

    context.linkTarget(context.breakTarget());
    context.endSwitch();
    return UNUSED;
}

template <class Context>
ContextExpression WASMFunctionParser::parseExpression(Context& context, WASMExpressionType expressionType)
{
    switch (expressionType) {
    case WASMExpressionType::I32:
        return parseExpressionI32(context);
    case WASMExpressionType::F32:
        return parseExpressionF32(context);
    case WASMExpressionType::F64:
        return parseExpressionF64(context);
    case WASMExpressionType::Void:
        return parseExpressionVoid(context);
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

template <class Context>
ContextExpression WASMFunctionParser::parseExpressionI32(Context& context)
{
    bool hasImmediate;
    WASMOpExpressionI32 op;
    WASMOpExpressionI32WithImmediate opWithImmediate;
    uint8_t immediate;
    READ_OP_EXPRESSION_I32_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, "Cannot read the int32 expression opcode.");
    if (!hasImmediate) {
        switch (op) {
        case WASMOpExpressionI32::ConstantPoolIndex:
            return parseConstantPoolIndexExpressionI32(context);
        case WASMOpExpressionI32::Immediate:
            return parseImmediateExpressionI32(context);
        case WASMOpExpressionI32::GetLocal:
            return parseGetLocalExpression(context, WASMType::I32);
        case WASMOpExpressionI32::GetGlobal:
            return parseGetGlobalExpression(context, WASMType::I32);
        case WASMOpExpressionI32::SetLocal:
            return parseSetLocal(context, WASMOpKind::Expression, WASMExpressionType::I32);
        case WASMOpExpressionI32::SetGlobal:
            return parseSetGlobal(context, WASMOpKind::Expression, WASMExpressionType::I32);
        case WASMOpExpressionI32::SLoad8:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::NoOffset, MemoryAccessConversion::SignExtend);
        case WASMOpExpressionI32::SLoadWithOffset8:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::WithOffset, MemoryAccessConversion::SignExtend);
        case WASMOpExpressionI32::ULoad8:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::NoOffset, MemoryAccessConversion::ZeroExtend);
        case WASMOpExpressionI32::ULoadWithOffset8:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::WithOffset, MemoryAccessConversion::ZeroExtend);
        case WASMOpExpressionI32::SLoad16:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::NoOffset, MemoryAccessConversion::SignExtend);
        case WASMOpExpressionI32::SLoadWithOffset16:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::WithOffset, MemoryAccessConversion::SignExtend);
        case WASMOpExpressionI32::ULoad16:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::NoOffset, MemoryAccessConversion::ZeroExtend);
        case WASMOpExpressionI32::ULoadWithOffset16:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::WithOffset, MemoryAccessConversion::ZeroExtend);
        case WASMOpExpressionI32::Load32:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I32, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionI32::LoadWithOffset32:
            return parseLoad(context, WASMExpressionType::I32, WASMMemoryType::I32, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionI32::Store8:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionI32::StoreWithOffset8:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::I32, WASMMemoryType::I8, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionI32::Store16:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionI32::StoreWithOffset16:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::I32, WASMMemoryType::I16, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionI32::Store32:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::I32, WASMMemoryType::I32, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionI32::StoreWithOffset32:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::I32, WASMMemoryType::I32, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionI32::CallInternal:
            return parseCallInternal(context, WASMOpKind::Expression, WASMExpressionType::I32);
        case WASMOpExpressionI32::CallIndirect:
            return parseCallIndirect(context, WASMOpKind::Expression, WASMExpressionType::I32);
        case WASMOpExpressionI32::CallImport:
            return parseCallImport(context, WASMOpKind::Expression, WASMExpressionType::I32);
        case WASMOpExpressionI32::Conditional:
            return parseConditional(context, WASMExpressionType::I32);
        case WASMOpExpressionI32::Comma:
            return parseComma(context, WASMExpressionType::I32);
        case WASMOpExpressionI32::FromF32:
            return parseConvertType(context, WASMExpressionType::F32, WASMExpressionType::I32, WASMTypeConversion::ConvertSigned);
        case WASMOpExpressionI32::FromF64:
            return parseConvertType(context, WASMExpressionType::F64, WASMExpressionType::I32, WASMTypeConversion::ConvertSigned);
        case WASMOpExpressionI32::Negate:
        case WASMOpExpressionI32::BitNot:
        case WASMOpExpressionI32::CountLeadingZeros:
        case WASMOpExpressionI32::LogicalNot:
        case WASMOpExpressionI32::Abs:
            return parseUnaryExpressionI32(context, op);
        case WASMOpExpressionI32::Add:
        case WASMOpExpressionI32::Sub:
        case WASMOpExpressionI32::Mul:
        case WASMOpExpressionI32::SDiv:
        case WASMOpExpressionI32::UDiv:
        case WASMOpExpressionI32::SMod:
        case WASMOpExpressionI32::UMod:
        case WASMOpExpressionI32::BitOr:
        case WASMOpExpressionI32::BitAnd:
        case WASMOpExpressionI32::BitXor:
        case WASMOpExpressionI32::LeftShift:
        case WASMOpExpressionI32::ArithmeticRightShift:
        case WASMOpExpressionI32::LogicalRightShift:
            return parseBinaryExpressionI32(context, op);
        case WASMOpExpressionI32::EqualI32:
        case WASMOpExpressionI32::NotEqualI32:
        case WASMOpExpressionI32::SLessThanI32:
        case WASMOpExpressionI32::ULessThanI32:
        case WASMOpExpressionI32::SLessThanOrEqualI32:
        case WASMOpExpressionI32::ULessThanOrEqualI32:
        case WASMOpExpressionI32::SGreaterThanI32:
        case WASMOpExpressionI32::UGreaterThanI32:
        case WASMOpExpressionI32::SGreaterThanOrEqualI32:
        case WASMOpExpressionI32::UGreaterThanOrEqualI32:
            return parseRelationalI32ExpressionI32(context, op);
        case WASMOpExpressionI32::EqualF32:
        case WASMOpExpressionI32::NotEqualF32:
        case WASMOpExpressionI32::LessThanF32:
        case WASMOpExpressionI32::LessThanOrEqualF32:
        case WASMOpExpressionI32::GreaterThanF32:
        case WASMOpExpressionI32::GreaterThanOrEqualF32:
            return parseRelationalF32ExpressionI32(context, op);
        case WASMOpExpressionI32::EqualF64:
        case WASMOpExpressionI32::NotEqualF64:
        case WASMOpExpressionI32::LessThanF64:
        case WASMOpExpressionI32::LessThanOrEqualF64:
        case WASMOpExpressionI32::GreaterThanF64:
        case WASMOpExpressionI32::GreaterThanOrEqualF64:
            return parseRelationalF64ExpressionI32(context, op);
        case WASMOpExpressionI32::SMin:
        case WASMOpExpressionI32::UMin:
        case WASMOpExpressionI32::SMax:
        case WASMOpExpressionI32::UMax:
            return parseMinOrMaxExpressionI32(context, op);
        default:
            ASSERT_NOT_REACHED();
        }
    } else {
        switch (opWithImmediate) {
        case WASMOpExpressionI32WithImmediate::ConstantPoolIndex:
            return parseConstantPoolIndexExpressionI32(context, immediate);
        case WASMOpExpressionI32WithImmediate::Immediate:
            return parseImmediateExpressionI32(context, immediate);
        case WASMOpExpressionI32WithImmediate::GetLocal:
            return parseGetLocalExpression(context, WASMType::I32, immediate);
        default:
            ASSERT_NOT_REACHED();
        }
    }
    return 0;
}

template <class Context>
ContextExpression WASMFunctionParser::parseConstantPoolIndexExpressionI32(Context& context, uint32_t constantPoolIndex)
{
    FAIL_IF_FALSE(constantPoolIndex < m_module->i32Constants().size(), "The constant pool index is incorrect.");
    return context.buildImmediateI32(m_module->i32Constants()[constantPoolIndex]);
}

template <class Context>
ContextExpression WASMFunctionParser::parseConstantPoolIndexExpressionI32(Context& context)
{
    uint32_t constantPoolIndex;
    READ_COMPACT_UINT32_OR_FAIL(constantPoolIndex, "Cannot read the constant pool index.");
    return parseConstantPoolIndexExpressionI32(context, constantPoolIndex);
}

template <class Context>
ContextExpression WASMFunctionParser::parseImmediateExpressionI32(Context& context, uint32_t immediate)
{
    return context.buildImmediateI32(immediate);
}

template <class Context>
ContextExpression WASMFunctionParser::parseImmediateExpressionI32(Context& context)
{
    uint32_t immediate;
    READ_COMPACT_UINT32_OR_FAIL(immediate, "Cannot read the immediate.");
    return parseImmediateExpressionI32(context, immediate);
}

template <class Context>
ContextExpression WASMFunctionParser::parseUnaryExpressionI32(Context& context, WASMOpExpressionI32 op)
{
    ContextExpression expression = parseExpressionI32(context);
    PROPAGATE_ERROR();
    return context.buildUnaryI32(expression, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseBinaryExpressionI32(Context& context, WASMOpExpressionI32 op)
{
    ContextExpression left = parseExpressionI32(context);
    PROPAGATE_ERROR();
    ContextExpression right = parseExpressionI32(context);
    PROPAGATE_ERROR();
    return context.buildBinaryI32(left, right, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseRelationalI32ExpressionI32(Context& context, WASMOpExpressionI32 op)
{
    ContextExpression left = parseExpressionI32(context);
    PROPAGATE_ERROR();
    ContextExpression right = parseExpressionI32(context);
    PROPAGATE_ERROR();
    return context.buildRelationalI32(left, right, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseRelationalF32ExpressionI32(Context& context, WASMOpExpressionI32 op)
{
    ContextExpression left = parseExpressionF32(context);
    PROPAGATE_ERROR();
    ContextExpression right = parseExpressionF32(context);
    PROPAGATE_ERROR();
    return context.buildRelationalF32(left, right, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseRelationalF64ExpressionI32(Context& context, WASMOpExpressionI32 op)
{
    ContextExpression left = parseExpressionF64(context);
    PROPAGATE_ERROR();
    ContextExpression right = parseExpressionF64(context);
    PROPAGATE_ERROR();
    return context.buildRelationalF64(left, right, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseMinOrMaxExpressionI32(Context& context, WASMOpExpressionI32 op)
{
    uint32_t numberOfArguments;
    READ_COMPACT_UINT32_OR_FAIL(numberOfArguments, "Cannot read the number of arguments to min/max.");
    FAIL_IF_FALSE(numberOfArguments >= 2, "Min/max must be passed at least 2 arguments.");
    ContextExpression current = parseExpressionI32(context);
    PROPAGATE_ERROR();
    for (uint32_t i = 1; i < numberOfArguments; ++i) {
        ContextExpression expression = parseExpressionI32(context);
        PROPAGATE_ERROR();
        current = context.buildMinOrMaxI32(current, expression, op);
    }
    return current;
}

template <class Context>
ContextExpression WASMFunctionParser::parseExpressionF32(Context& context)
{
    bool hasImmediate;
    WASMOpExpressionF32 op;
    WASMOpExpressionF32WithImmediate opWithImmediate;
    uint8_t immediate;
    READ_OP_EXPRESSION_F32_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, "Cannot read the float32 expression opcode.");
    if (!hasImmediate) {
        switch (op) {
        case WASMOpExpressionF32::ConstantPoolIndex:
            return parseConstantPoolIndexExpressionF32(context);
        case WASMOpExpressionF32::Immediate:
            return parseImmediateExpressionF32(context);
        case WASMOpExpressionF32::GetLocal:
            return parseGetLocalExpression(context, WASMType::F32);
        case WASMOpExpressionF32::GetGlobal:
            return parseGetGlobalExpression(context, WASMType::F32);
        case WASMOpExpressionF32::SetLocal:
            return parseSetLocal(context, WASMOpKind::Expression, WASMExpressionType::F32);
        case WASMOpExpressionF32::SetGlobal:
            return parseSetGlobal(context, WASMOpKind::Expression, WASMExpressionType::F32);
        case WASMOpExpressionF32::Load:
            return parseLoad(context, WASMExpressionType::F32, WASMMemoryType::F32, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionF32::LoadWithOffset:
            return parseLoad(context, WASMExpressionType::F32, WASMMemoryType::F32, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionF32::Store:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::F32, WASMMemoryType::F32, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionF32::StoreWithOffset:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::F32, WASMMemoryType::F32, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionF32::CallInternal:
            return parseCallInternal(context, WASMOpKind::Expression, WASMExpressionType::F32);
        case WASMOpExpressionF32::CallIndirect:
            return parseCallIndirect(context, WASMOpKind::Expression, WASMExpressionType::F32);
        case WASMOpExpressionF32::Conditional:
            return parseConditional(context, WASMExpressionType::F32);
        case WASMOpExpressionF32::Comma:
            return parseComma(context, WASMExpressionType::F32);
        case WASMOpExpressionF32::FromS32:
            return parseConvertType(context, WASMExpressionType::I32, WASMExpressionType::F32, WASMTypeConversion::ConvertSigned);
        case WASMOpExpressionF32::FromU32:
            return parseConvertType(context, WASMExpressionType::I32, WASMExpressionType::F32, WASMTypeConversion::ConvertUnsigned);
        case WASMOpExpressionF32::FromF64:
            return parseConvertType(context, WASMExpressionType::F64, WASMExpressionType::F32, WASMTypeConversion::Demote);
        case WASMOpExpressionF32::Negate:
        case WASMOpExpressionF32::Abs:
        case WASMOpExpressionF32::Ceil:
        case WASMOpExpressionF32::Floor:
        case WASMOpExpressionF32::Sqrt:
            return parseUnaryExpressionF32(context, op);
        case WASMOpExpressionF32::Add:
        case WASMOpExpressionF32::Sub:
        case WASMOpExpressionF32::Mul:
        case WASMOpExpressionF32::Div:
            return parseBinaryExpressionF32(context, op);
        default:
            ASSERT_NOT_REACHED();
        }
    } else {
        switch (opWithImmediate) {
        case WASMOpExpressionF32WithImmediate::ConstantPoolIndex:
            return parseConstantPoolIndexExpressionF32(context, immediate);
        case WASMOpExpressionF32WithImmediate::GetLocal:
            return parseGetLocalExpression(context, WASMType::F32, immediate);
        default:
            ASSERT_NOT_REACHED();
        }
    }
    return 0;
}

template <class Context>
ContextExpression WASMFunctionParser::parseConstantPoolIndexExpressionF32(Context& context, uint32_t constantIndex)
{
    FAIL_IF_FALSE(constantIndex < m_module->f32Constants().size(), "The constant pool index is incorrect.");
    return context.buildImmediateF32(m_module->f32Constants()[constantIndex]);
}

template <class Context>
ContextExpression WASMFunctionParser::parseConstantPoolIndexExpressionF32(Context& context)
{
    uint32_t constantIndex;
    READ_COMPACT_UINT32_OR_FAIL(constantIndex, "Cannot read the constant pool index.");
    return parseConstantPoolIndexExpressionF32(context, constantIndex);
}

template <class Context>
ContextExpression WASMFunctionParser::parseImmediateExpressionF32(Context& context)
{
    float immediate;
    READ_FLOAT_OR_FAIL(immediate, "Cannot read the immediate.");
    return context.buildImmediateF32(immediate);
}

template <class Context>
ContextExpression WASMFunctionParser::parseUnaryExpressionF32(Context& context, WASMOpExpressionF32 op)
{
    ContextExpression expression = parseExpressionF32(context);
    PROPAGATE_ERROR();
    return context.buildUnaryF32(expression, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseBinaryExpressionF32(Context& context, WASMOpExpressionF32 op)
{
    ContextExpression left = parseExpressionF32(context);
    PROPAGATE_ERROR();
    ContextExpression right = parseExpressionF32(context);
    PROPAGATE_ERROR();
    return context.buildBinaryF32(left, right, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseExpressionF64(Context& context)
{
    bool hasImmediate;
    WASMOpExpressionF64 op;
    WASMOpExpressionF64WithImmediate opWithImmediate;
    uint8_t immediate;
    READ_OP_EXPRESSION_F64_OR_FAIL(hasImmediate, op, opWithImmediate, immediate, "Cannot read the float64 expression opcode.");
    if (!hasImmediate) {
        switch (op) {
        case WASMOpExpressionF64::ConstantPoolIndex:
            return parseConstantPoolIndexExpressionF64(context);
        case WASMOpExpressionF64::Immediate:
            return parseImmediateExpressionF64(context);
        case WASMOpExpressionF64::GetLocal:
            return parseGetLocalExpression(context, WASMType::F64);
        case WASMOpExpressionF64::GetGlobal:
            return parseGetGlobalExpression(context, WASMType::F64);
        case WASMOpExpressionF64::SetLocal:
            return parseSetLocal(context, WASMOpKind::Expression, WASMExpressionType::F64);
        case WASMOpExpressionF64::SetGlobal:
            return parseSetGlobal(context, WASMOpKind::Expression, WASMExpressionType::F64);
        case WASMOpExpressionF64::Load:
            return parseLoad(context, WASMExpressionType::F64, WASMMemoryType::F64, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionF64::LoadWithOffset:
            return parseLoad(context, WASMExpressionType::F64, WASMMemoryType::F64, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionF64::Store:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::F64, WASMMemoryType::F64, MemoryAccessOffsetMode::NoOffset);
        case WASMOpExpressionF64::StoreWithOffset:
            return parseStore(context, WASMOpKind::Expression, WASMExpressionType::F64, WASMMemoryType::F64, MemoryAccessOffsetMode::WithOffset);
        case WASMOpExpressionF64::CallInternal:
            return parseCallInternal(context, WASMOpKind::Expression, WASMExpressionType::F64);
        case WASMOpExpressionF64::CallImport:
            return parseCallImport(context, WASMOpKind::Expression, WASMExpressionType::F64);
        case WASMOpExpressionF64::CallIndirect:
            return parseCallIndirect(context, WASMOpKind::Expression, WASMExpressionType::F64);
        case WASMOpExpressionF64::Conditional:
            return parseConditional(context, WASMExpressionType::F64);
        case WASMOpExpressionF64::Comma:
            return parseComma(context, WASMExpressionType::F64);
        case WASMOpExpressionF64::FromS32:
            return parseConvertType(context, WASMExpressionType::I32, WASMExpressionType::F64, WASMTypeConversion::ConvertSigned);
        case WASMOpExpressionF64::FromU32:
            return parseConvertType(context, WASMExpressionType::I32, WASMExpressionType::F64, WASMTypeConversion::ConvertUnsigned);
        case WASMOpExpressionF64::FromF32:
            return parseConvertType(context, WASMExpressionType::F32, WASMExpressionType::F64, WASMTypeConversion::Promote);
        case WASMOpExpressionF64::Negate:
        case WASMOpExpressionF64::Abs:
        case WASMOpExpressionF64::Ceil:
        case WASMOpExpressionF64::Floor:
        case WASMOpExpressionF64::Sqrt:
        case WASMOpExpressionF64::Cos:
        case WASMOpExpressionF64::Sin:
        case WASMOpExpressionF64::Tan:
        case WASMOpExpressionF64::ACos:
        case WASMOpExpressionF64::ASin:
        case WASMOpExpressionF64::ATan:
        case WASMOpExpressionF64::Exp:
        case WASMOpExpressionF64::Ln:
            return parseUnaryExpressionF64(context, op);
        case WASMOpExpressionF64::Add:
        case WASMOpExpressionF64::Sub:
        case WASMOpExpressionF64::Mul:
        case WASMOpExpressionF64::Div:
        case WASMOpExpressionF64::Mod:
        case WASMOpExpressionF64::ATan2:
        case WASMOpExpressionF64::Pow:
            return parseBinaryExpressionF64(context, op);
        case WASMOpExpressionF64::Min:
        case WASMOpExpressionF64::Max:
            return parseMinOrMaxExpressionF64(context, op);
        default:
            ASSERT_NOT_REACHED();
        }
    } else {
        switch (opWithImmediate) {
        case WASMOpExpressionF64WithImmediate::ConstantPoolIndex:
            return parseConstantPoolIndexExpressionF64(context, immediate);
        case WASMOpExpressionF64WithImmediate::GetLocal:
            return parseGetLocalExpression(context, WASMType::F64, immediate);
        default:
            ASSERT_NOT_REACHED();
        }
    }
    return 0;
}

template <class Context>
ContextExpression WASMFunctionParser::parseConstantPoolIndexExpressionF64(Context& context, uint32_t constantIndex)
{
    FAIL_IF_FALSE(constantIndex < m_module->f64Constants().size(), "The constant index is incorrect.");
    return context.buildImmediateF64(m_module->f64Constants()[constantIndex]);
}

template <class Context>
ContextExpression WASMFunctionParser::parseConstantPoolIndexExpressionF64(Context& context)
{
    uint32_t constantIndex;
    READ_COMPACT_UINT32_OR_FAIL(constantIndex, "Cannot read the constant index.");
    return parseConstantPoolIndexExpressionF64(context, constantIndex);
}

template <class Context>
ContextExpression WASMFunctionParser::parseImmediateExpressionF64(Context& context)
{
    double immediate;
    READ_DOUBLE_OR_FAIL(immediate, "Cannot read the immediate.");
    return context.buildImmediateF64(immediate);
}

template <class Context>
ContextExpression WASMFunctionParser::parseUnaryExpressionF64(Context& context, WASMOpExpressionF64 op)
{
    ContextExpression expression = parseExpressionF64(context);
    PROPAGATE_ERROR();
    return context.buildUnaryF64(expression, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseBinaryExpressionF64(Context& context, WASMOpExpressionF64 op)
{
    ContextExpression left = parseExpressionF64(context);
    PROPAGATE_ERROR();
    ContextExpression right = parseExpressionF64(context);
    PROPAGATE_ERROR();
    return context.buildBinaryF64(left, right, op);
}

template <class Context>
ContextExpression WASMFunctionParser::parseMinOrMaxExpressionF64(Context& context, WASMOpExpressionF64 op)
{
    uint32_t numberOfArguments;
    READ_COMPACT_UINT32_OR_FAIL(numberOfArguments, "Cannot read the number of arguments to min/max.");
    FAIL_IF_FALSE(numberOfArguments >= 2, "Min/max must be passed at least 2 arguments.");
    ContextExpression current = parseExpressionF64(context);
    PROPAGATE_ERROR();
    for (uint32_t i = 1; i < numberOfArguments; ++i) {
        ContextExpression expression = parseExpressionF64(context);
        PROPAGATE_ERROR();
        current = context.buildMinOrMaxF64(current, expression, op);
    }
    return current;
}

template <class Context>
ContextExpression WASMFunctionParser::parseExpressionVoid(Context& context)
{
    WASMOpExpressionVoid op;
    READ_OP_EXPRESSION_VOID_OR_FAIL(op, "Cannot read the void expression opcode.");
    switch (op) {
    case WASMOpExpressionVoid::CallInternal:
        return parseCallInternal(context, WASMOpKind::Expression, WASMExpressionType::Void);
    case WASMOpExpressionVoid::CallIndirect:
        return parseCallIndirect(context, WASMOpKind::Expression, WASMExpressionType::Void);
    case WASMOpExpressionVoid::CallImport:
        return parseCallImport(context, WASMOpKind::Expression, WASMExpressionType::Void);
    default:
        RELEASE_ASSERT_NOT_REACHED();
    }
}

template <class Context>
ContextExpression WASMFunctionParser::parseGetLocalExpression(Context& context, WASMType type, uint32_t localIndex)
{
    FAIL_IF_FALSE(localIndex < m_localTypes.size(), "The local index is incorrect.");
    FAIL_IF_FALSE(m_localTypes[localIndex] == type, "Expected a local of type " + nameOfType(type) + '.');
    return context.buildGetLocal(localIndex, type);
}

template <class Context>
ContextExpression WASMFunctionParser::parseGetLocalExpression(Context& context, WASMType type)
{
    uint32_t localIndex;
    READ_COMPACT_UINT32_OR_FAIL(localIndex, "Cannot read the local index.");
    return parseGetLocalExpression(context, type, localIndex);
}

template <class Context>
ContextExpression WASMFunctionParser::parseGetGlobalExpression(Context& context, WASMType type)
{
    uint32_t globalIndex;
    READ_COMPACT_UINT32_OR_FAIL(globalIndex, "Cannot read the global index.");
    FAIL_IF_FALSE(globalIndex < m_module->globalVariableTypes().size(), "The global index is incorrect.");
    FAIL_IF_FALSE(m_module->globalVariableTypes()[globalIndex] == type, "Expected a global of type " + nameOfType(type) + '.');
    return context.buildGetGlobal(globalIndex, type);
}

template <class Context>
ContextExpression WASMFunctionParser::parseSetLocal(Context& context, WASMOpKind opKind, WASMExpressionType expressionType, uint32_t localIndex)
{
    FAIL_IF_FALSE(localIndex < m_localTypes.size(), "The local variable index is incorrect.");
    WASMType type = m_localTypes[localIndex];
    if (opKind == WASMOpKind::Expression)
        FAIL_IF_FALSE(expressionType == WASMExpressionType(type), "The type doesn't match.");
    ContextExpression expression = parseExpression(context, WASMExpressionType(type));
    PROPAGATE_ERROR();
    return context.buildSetLocal(opKind, localIndex, expression, type);
}

template <class Context>
ContextExpression WASMFunctionParser::parseSetLocal(Context& context, WASMOpKind opKind, WASMExpressionType expressionType)
{
    uint32_t localIndex;
    READ_COMPACT_UINT32_OR_FAIL(localIndex, "Cannot read the local index.");
    return parseSetLocal(context, opKind, expressionType, localIndex);
}

template <class Context>
ContextExpression WASMFunctionParser::parseSetGlobal(Context& context, WASMOpKind opKind, WASMExpressionType expressionType, uint32_t globalIndex)
{
    FAIL_IF_FALSE(globalIndex < m_module->globalVariableTypes().size(), "The global index is incorrect.");
    WASMType type = m_module->globalVariableTypes()[globalIndex];
    if (opKind == WASMOpKind::Expression)
        FAIL_IF_FALSE(expressionType == WASMExpressionType(type), "The type doesn't match.");
    ContextExpression expression = parseExpression(context, WASMExpressionType(type));
    PROPAGATE_ERROR();
    return context.buildSetGlobal(opKind, globalIndex, expression, type);
}

template <class Context>
ContextExpression WASMFunctionParser::parseSetGlobal(Context& context, WASMOpKind opKind, WASMExpressionType expressionType)
{
    uint32_t globalIndex;
    READ_COMPACT_UINT32_OR_FAIL(globalIndex, "Cannot read the global index.");
    return parseSetGlobal(context, opKind, expressionType, globalIndex);
}

template <class Context>
ContextMemoryAddress WASMFunctionParser::parseMemoryAddress(Context& context, MemoryAccessOffsetMode offsetMode)
{
    uint32_t offset = 0;
    if (offsetMode == MemoryAccessOffsetMode::WithOffset)
        READ_COMPACT_UINT32_OR_FAIL(offset, "Cannot read the address offset.");
    ContextExpression index = parseExpressionI32(context);
    PROPAGATE_ERROR();
    return ContextMemoryAddress(index, offset);
}

template <class Context>
ContextExpression WASMFunctionParser::parseLoad(Context& context, WASMExpressionType expressionType, WASMMemoryType memoryType, MemoryAccessOffsetMode offsetMode, MemoryAccessConversion conversion)
{
    FAIL_IF_FALSE(m_module->arrayBuffer(), "An ArrayBuffer is not provided.");
    const ContextMemoryAddress& memoryAddress = parseMemoryAddress(context, offsetMode);
    PROPAGATE_ERROR();
    return context.buildLoad(memoryAddress, expressionType, memoryType, conversion);
}

template <class Context>
ContextExpression WASMFunctionParser::parseStore(Context& context, WASMOpKind opKind, WASMExpressionType expressionType, WASMMemoryType memoryType, MemoryAccessOffsetMode offsetMode)
{
    FAIL_IF_FALSE(m_module->arrayBuffer(), "An ArrayBuffer is not provided.");
    const ContextMemoryAddress& memoryAddress = parseMemoryAddress(context, offsetMode);
    PROPAGATE_ERROR();

    ContextExpression value = parseExpression(context, expressionType);
    PROPAGATE_ERROR();
    return context.buildStore(opKind, memoryAddress, expressionType, memoryType, value);
}

template <class Context>
ContextExpressionList WASMFunctionParser::parseCallArguments(Context& context, const Vector<WASMType>& arguments)
{
    ContextExpressionList argumentList;
    for (size_t i = 0; i < arguments.size(); ++i) {
        ContextExpression expression = parseExpression(context, WASMExpressionType(arguments[i]));
        PROPAGATE_ERROR();
        context.appendExpressionList(argumentList, expression);
    }
    return argumentList;
}

template <class Context>
ContextExpression WASMFunctionParser::parseCallInternal(Context& context, WASMOpKind opKind, WASMExpressionType returnType)
{
    uint32_t functionIndex;
    READ_COMPACT_UINT32_OR_FAIL(functionIndex, "Cannot read the function index.");
    FAIL_IF_FALSE(functionIndex < m_module->functionDeclarations().size(), "The function index is incorrect.");
    const WASMSignature& signature = m_module->signatures()[m_module->functionDeclarations()[functionIndex].signatureIndex];
    if (opKind == WASMOpKind::Expression)
        FAIL_IF_FALSE(signature.returnType == returnType, "Wrong return type.");

    ContextExpressionList argumentList = parseCallArguments(context, signature.arguments);
    PROPAGATE_ERROR();
    return context.buildCallInternal(functionIndex, argumentList, signature, returnType);
}

template <class Context>
ContextExpression WASMFunctionParser::parseCallIndirect(Context& context, WASMOpKind opKind, WASMExpressionType returnType)
{
    uint32_t functionPointerTableIndex;
    READ_COMPACT_UINT32_OR_FAIL(functionPointerTableIndex, "Cannot read the function pointer table index.");
    FAIL_IF_FALSE(functionPointerTableIndex < m_module->functionPointerTables().size(), "The function pointer table index is incorrect.");
    const WASMFunctionPointerTable& functionPointerTable = m_module->functionPointerTables()[functionPointerTableIndex];
    const WASMSignature& signature = m_module->signatures()[functionPointerTable.signatureIndex];
    if (opKind == WASMOpKind::Expression)
        FAIL_IF_FALSE(signature.returnType == returnType, "Wrong return type.");

    ContextExpression index = parseExpressionI32(context);
    PROPAGATE_ERROR();

    ContextExpressionList argumentList = parseCallArguments(context, signature.arguments);
    PROPAGATE_ERROR();
    return context.buildCallIndirect(functionPointerTableIndex, index, argumentList, signature, returnType);
}

template <class Context>
ContextExpression WASMFunctionParser::parseCallImport(Context& context, WASMOpKind opKind, WASMExpressionType returnType)
{
    uint32_t functionImportSignatureIndex;
    READ_COMPACT_UINT32_OR_FAIL(functionImportSignatureIndex, "Cannot read the function import signature index.");
    FAIL_IF_FALSE(functionImportSignatureIndex < m_module->functionImportSignatures().size(), "The function import signature index is incorrect.");
    const WASMFunctionImportSignature& functionImportSignature = m_module->functionImportSignatures()[functionImportSignatureIndex];
    const WASMSignature& signature = m_module->signatures()[functionImportSignature.signatureIndex];
    if (opKind == WASMOpKind::Expression)
        FAIL_IF_FALSE(signature.returnType == returnType, "Wrong return type.");

    ContextExpressionList argumentList = parseCallArguments(context, signature.arguments);
    PROPAGATE_ERROR();
    return context.buildCallImport(functionImportSignature.functionImportIndex, argumentList, signature, returnType);
}

template <class Context>
ContextExpression WASMFunctionParser::parseConditional(Context& context, WASMExpressionType expressionType)
{
    ContextJumpTarget elseTarget;
    ContextJumpTarget end;

    ContextExpression condition = parseExpressionI32(context);
    PROPAGATE_ERROR();

    context.jumpToTargetIf(Context::JumpCondition::Zero, condition, elseTarget);

    parseExpression(context, expressionType);
    PROPAGATE_ERROR();
    
    context.jumpToTarget(end);
    context.linkTarget(elseTarget);

    // We use discard() here to decrement the stack top in the baseline JIT.
    context.discard(UNUSED);
    parseExpression(context, expressionType);
    PROPAGATE_ERROR();
    
    context.linkTarget(end);
    return UNUSED;
}

template <class Context>
ContextExpression WASMFunctionParser::parseComma(Context& context, WASMExpressionType expressionType)
{
    WASMExpressionType leftExpressionType;
    READ_EXPRESSION_TYPE_OR_FAIL(leftExpressionType, "Cannot read the expression type.");
    ContextExpression leftExpression = parseExpression(context, leftExpressionType);
    PROPAGATE_ERROR();
    if (leftExpressionType != WASMExpressionType::Void)
        context.discard(leftExpression);
    return parseExpression(context, expressionType);
}

template <class Context>
ContextExpression WASMFunctionParser::parseConvertType(Context& context, WASMExpressionType fromType, WASMExpressionType toType, WASMTypeConversion conversion)
{
    ContextExpression expression = parseExpression(context, fromType);
    PROPAGATE_ERROR();

    return context.buildConvertType(expression, fromType, toType, conversion);
}

} // namespace JSC

#endif // ENABLE(WEBASSEMBLY)