2015-07-02  Sukolsak Sakshuwong  <sukolsak@gmail.com>

        JSC should natively support WebAssembly

        https://bugs.webkit.org/show_bug.cgi?id=146064

        Reviewed by NOBODY (OOPS!).

        * JavaScriptCore.xcodeproj/project.pbxproj:

        * jsc.cpp:

        (GlobalObject::finishCreation):

        (functionLoadWebAssembly):

        * wasm/WasmJITCompiler.cpp: Added.

        (JSC::Wasm::JumpScope::JumpScope):

        (JSC::Wasm::JumpScope::jump):

        (JSC::Wasm::JumpScope::link):

        (JSC::Wasm::JITCompiler::compileAndRun):

        (JSC::Wasm::JITCompiler::compile):

        (JSC::Wasm::JITCompiler::unpack):

        (JSC::Wasm::JITCompiler::readSignatureSection):

        (JSC::Wasm::JITCompiler::readFunctionImportSection):

        (JSC::Wasm::JITCompiler::readGlobalSection):

        (JSC::Wasm::JITCompiler::readConstantPoolSection):

        (JSC::Wasm::JITCompiler::readFunctionDeclarationSection):

        (JSC::Wasm::JITCompiler::readFunctionPointerTables):

        (JSC::Wasm::JITCompiler::readFunctionDefinitionSection):

        (JSC::Wasm::JITCompiler::readExportSection):

        (JSC::Wasm::JITCompiler::readFunctionDefinition):

        (JSC::Wasm::JITCompiler::readArgs):

        (JSC::Wasm::JITCompiler::readVars):

        (JSC::Wasm::JITCompiler::stmt):

        (JSC::Wasm::JITCompiler::get_local):

        (JSC::Wasm::JITCompiler::set_local):

        (JSC::Wasm::JITCompiler::return_stmt):

        (JSC::Wasm::JITCompiler::stmt_list):

        (JSC::Wasm::JITCompiler::block_stmt):

        (JSC::Wasm::JITCompiler::if_stmt):

        (JSC::Wasm::JITCompiler::if_else_stmt):

        (JSC::Wasm::JITCompiler::while_stmt):

        (JSC::Wasm::JITCompiler::do_stmt):

        (JSC::Wasm::JITCompiler::label_stmt):

        (JSC::Wasm::JITCompiler::break_label_stmt):

        (JSC::Wasm::JITCompiler::continue_label_stmt):

        (JSC::Wasm::JITCompiler::switch_stmt):

        (JSC::Wasm::JITCompiler::expr):

        (JSC::Wasm::JITCompiler::signed_expr):

        (JSC::Wasm::JITCompiler::add_sub):

        (JSC::Wasm::JITCompiler::mul_i32):

        (JSC::Wasm::JITCompiler::rel_i32):

        (JSC::Wasm::JITCompiler::comma):

        (JSC::Wasm::JITCompiler::cond):

        (JSC::Wasm::compileAndRun):

        * wasm/WasmJITCompiler.h: Added.

        (JSC::Wasm::JITCompiler::JITCompiler):

        (JSC::Wasm::JITCompiler::stackAddress):

        (JSC::Wasm::JITCompiler::temporaryAddress):

        (JSC::Wasm::JITCompiler::pushContinueLabelLabel):

        (JSC::Wasm::JITCompiler::popContinueLabelLabel):

        (JSC::Wasm::JITCompiler::continueLabelLabel):

        (JSC::Wasm::JITCompiler::pushBreakLabelJumpList):

        (JSC::Wasm::JITCompiler::popBreakLabelJumpList):

        (JSC::Wasm::JITCompiler::breakLabelJumpList):

        (JSC::Wasm::JITCompiler::pushContinueJumpScope):

        (JSC::Wasm::JITCompiler::popContinueJumpScope):

        (JSC::Wasm::JITCompiler::topContinueJumpScope):

        (JSC::Wasm::JITCompiler::pushBreakJumpList):

        (JSC::Wasm::JITCompiler::popBreakJumpList):

        (JSC::Wasm::JITCompiler::topBreakJumpList):

        * wasm/WasmOpcodes.h: Added.

        (JSC::Wasm::operator|):

        (JSC::Wasm::operator&):

        (JSC::Wasm::Expr::Expr):

        (JSC::Wasm::Expr::Bad):

        (JSC::Wasm::Expr::is_bad):

        (JSC::Wasm::Expr::type):

        (JSC::Wasm::Expr::i32):

        (JSC::Wasm::Expr::f32):

        (JSC::Wasm::Expr::f64):

        (JSC::Wasm::Expr::operator==):

        (JSC::Wasm::Expr::operator!=):

        (JSC::Wasm::PackOpWithImm):

        (JSC::Wasm::UnpackOpWithImm):

        (JSC::Wasm::ExprWithImm::ExprWithImm):

        (JSC::Wasm::ExprWithImm::is_bad):

        (JSC::Wasm::ExprWithImm::type):

        (JSC::Wasm::ExprWithImm::i32):

        (JSC::Wasm::ExprWithImm::f32):

        (JSC::Wasm::ExprWithImm::f64):

        (JSC::Wasm::Signature::Signature):

        (JSC::Wasm::Signature::operator==):

        (JSC::Wasm::Signature::operator!=):

        (JSC::Wasm::Signature::Hash::operator()):

        (JSC::Wasm::In::In):

        (JSC::Wasm::In::stmt):

        (JSC::Wasm::In::switchCase):

        (JSC::Wasm::In::voidExpr):

        (JSC::Wasm::In::exportFormat):

        (JSC::Wasm::In::type):

        (JSC::Wasm::In::rtype):

        (JSC::Wasm::In::singleChar):

        (JSC::Wasm::In::u8):

        (JSC::Wasm::In::fixedWidth<uint32_t>):

        (JSC::Wasm::In::fixedWidth<float>):

        (JSC::Wasm::In::fixedWidth<double>):

        (JSC::Wasm::In::code):

        (JSC::Wasm::In::immU32):

        (JSC::Wasm::In::immS32):

        (JSC::Wasm::In::ifI32Lit):

		7B545E501B4605C70029390E /* WasmJITCompiler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B545E4D1B4605C30029390E /* WasmJITCompiler.cpp */; };

		7B545E511B4605D30029390E /* WasmJITCompiler.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B545E4E1B4605C30029390E /* WasmJITCompiler.h */; settings = {ATTRIBUTES = (Private, ); }; };

		7B545E521B4605D80029390E /* WasmOpcodes.h in Headers */ = {isa = PBXBuildFile; fileRef = 7B545E4F1B4605C30029390E /* WasmOpcodes.h */; settings = {ATTRIBUTES = (Private, ); }; };

		7B545E4D1B4605C30029390E /* WasmJITCompiler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WasmJITCompiler.cpp; sourceTree = "<group>"; };

		7B545E4E1B4605C30029390E /* WasmJITCompiler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmJITCompiler.h; sourceTree = "<group>"; };

		7B545E4F1B4605C30029390E /* WasmOpcodes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmOpcodes.h; sourceTree = "<group>"; };

				7B545E4C1B4605A30029390E /* wasm */,

		7B545E4C1B4605A30029390E /* wasm */ = {

			isa = PBXGroup;

			children = (

				7B545E4D1B4605C30029390E /* WasmJITCompiler.cpp */,

				7B545E4E1B4605C30029390E /* WasmJITCompiler.h */,

				7B545E4F1B4605C30029390E /* WasmOpcodes.h */,

			);

			path = wasm;

			sourceTree = "<group>";

		};

				7B545E521B4605D80029390E /* WasmOpcodes.h in Headers */,

				7B545E511B4605D30029390E /* WasmJITCompiler.h in Headers */,

				7B545E501B4605C70029390E /* WasmJITCompiler.cpp in Sources */,

#include "WasmJITCompiler.h"

static EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState*);

        addFunction(vm, "loadWebAssembly", functionLoadWebAssembly, 1);

EncodedJSValue JSC_HOST_CALL functionLoadWebAssembly(ExecState* exec)

{

    String fileName = exec->argument(0).toString(exec)->value(exec);

    Vector<char> buffer;

    if (!fillBufferWithContentsOfFile(fileName, buffer))

        return JSValue::encode(exec->vm().throwException(exec, createError(exec, ASCIILiteral("Could not open file."))));

    JSValue result = Wasm::compileAndRun(exec, buffer);

    return JSValue::encode(result);

}

/*

 * 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 "WasmJITCompiler.h"

#include "JITCode.h"

#include "JSCallee.h"

#include "LinkBuffer.h"

#include "ProtoCallFrame.h"

namespace JSC {

namespace Wasm {

class JumpScope {

public:

    JumpScope(MacroAssembler* macroAssembler)

    : m_macroAssembler(macroAssembler)

    , m_linked(false)

    {

    }

    JumpScope(MacroAssembler* macroAssembler, const MacroAssembler::Label& label)

    : m_macroAssembler(macroAssembler)

    , m_linked(true)

    , m_label(label)

    {

    }

    void jump()

    {

        if (m_linked)

            m_macroAssembler->jump(m_label);

        else

            m_jumpList.append(m_macroAssembler->jump());

    }

    void link()

    {

        ASSERT(!m_linked);

        m_jumpList.link(m_macroAssembler);

    }

private:

    MacroAssembler* m_macroAssembler;

    bool m_linked;

    MacroAssembler::Label m_label;

    MacroAssembler::JumpList m_jumpList;

};

JSValue JITCompiler::compileAndRun(ExecState* exec, const Vector<char>& buffer)

{

    VM& vm = exec->vm();

    RefPtr<JITCode> jitCode = compile(vm, buffer);

    ProtoCallFrame protoCallFrame;

    protoCallFrame.init(0, JSCallee::create(vm, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()), jsUndefined(), 1);

    return jitCode->execute(&vm, &protoCallFrame);

}

RefPtr<JITCode> JITCompiler::compile(VM& vm, const Vector<char>& buffer)

{

    emitFunctionPrologue();

    m_read = In(reinterpret_cast<const uint8_t*>(buffer.data()));

    if (m_read.fixedWidth<uint32_t>() != MagicNumber)

        abort();

    m_read.fixedWidth<uint32_t>(); // out_size

    unpack();

    boxInt52(GPRInfo::returnValueGPR, GPRInfo::returnValueGPR, GPRInfo::regT0, FPRInfo::fpRegT0);

    emitFunctionEpilogue();

    ret();

    JITCompilationEffort effort = JITCompilationMustSucceed;

    LinkBuffer patchBuffer(vm, *this, 0, effort);

    MacroAssemblerCodePtr withArityCheck;

    CodeRef result = FINALIZE_CODE(patchBuffer, ("Baseline JIT code for WebAssembly"));

    // TODO: should create a new jitType

    return adoptRef(new DirectJITCode(result, withArityCheck, JITCode::BaselineJIT));

}

void JITCompiler::unpack()

{

    readConstantPoolSection();

    readSignatureSection();

    readFunctionImportSection();

    readGlobalSection();

    readFunctionDeclarationSection();

    readFunctionPointerTables();

    readFunctionDefinitionSection();

    readExportSection();

}

void JITCompiler::readSignatureSection()

{

    uint32_t numSignatures = m_read.immU32();

    Vector<Signature> signatures(numSignatures);

    for (uint32_t signatureIndex = 0; signatureIndex < numSignatures; signatureIndex++) {

        RType ret = m_read.rtype();

        uint32_t numArgs = m_read.immU32();

        Signature signature(ret, numArgs);

        for (uint32_t argumentIndex = 0; argumentIndex < numArgs; argumentIndex++)

            signature.args[argumentIndex] = m_read.type();

        signatures[signatureIndex] = WTF::move(signature);

    }

    m_signatures = WTF::move(signatures);

}

void JITCompiler::readFunctionImportSection()

{

    uint32_t numFuncImps = m_read.immU32();

    uint32_t numFuncImportSignatures = m_read.immU32();

    Vector<FuncImportSignature> funcImportSignatures(numFuncImportSignatures);

    FuncImportSignature* funcImportSignature = funcImportSignatures.data();

    for (uint32_t func_imp_i = 0; func_imp_i < numFuncImps; func_imp_i++) {

        while (m_read.singleChar()) { }

        uint32_t numSigs = m_read.immU32();

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

            funcImportSignature->signatureIndex = m_read.immU32();

            funcImportSignature->funcImportIndex = func_imp_i;

            funcImportSignature++;

        }

    }

    assert(funcImportSignature == funcImportSignatures.data() + numFuncImportSignatures);

    m_funcImportSignatures = WTF::move(funcImportSignatures);

}

void JITCompiler::readGlobalSection()

{

    uint32_t num_i32_zero = m_read.immU32();

    uint32_t num_f32_zero = m_read.immU32();

    uint32_t num_f64_zero = m_read.immU32();

    uint32_t num_i32_import = m_read.immU32();

    uint32_t num_f32_import = m_read.immU32();

    uint32_t num_f64_import = m_read.immU32();

    uint32_t numGlobalVars = num_i32_zero + num_f32_zero + num_f64_zero + num_i32_import + num_f32_import + num_f64_import;

    Vector<Type> globalTypes(numGlobalVars);

    size_t globalTypeIndex = 0;

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

        globalTypes[globalTypeIndex++] = Type::I32;

    }

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

        globalTypes[globalTypeIndex++] = Type::F32;

    }

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

        globalTypes[globalTypeIndex++] = Type::F64;

    }

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

        while (m_read.singleChar()) { }

        globalTypes[globalTypeIndex++] = Type::I32;

    }

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

        while (m_read.singleChar()) { }

        globalTypes[globalTypeIndex++] = Type::F32;

    }

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

        while (m_read.singleChar()) { }

        globalTypes[globalTypeIndex++] = Type::F64;

    }

    m_globalTypes = WTF::move(globalTypes);

}

void JITCompiler::readConstantPoolSection()

{

    uint32_t numI32s = m_read.immU32();

    uint32_t numF32s = m_read.immU32();

    uint32_t numF64s = m_read.immU32();

    Vector<uint32_t> i32s(numI32s);

    for (uint32_t i = 0; i < numI32s; i++)

        i32s[i] = m_read.immU32();

    Vector<float> f32s(numF32s);

    for (uint32_t i = 0; i < numF32s; i++)

        f32s[i] = m_read.fixedWidth<float>();

    Vector<double> f64s(numF64s);

    for (uint32_t i = 0; i < numF64s; i++)

        f64s[i] = m_read.fixedWidth<double>();

    m_i32s = WTF::move(i32s);

    m_f32s = WTF::move(f32s);

    m_f64s = WTF::move(f64s);

}

void JITCompiler::readFunctionDeclarationSection()

{

    uint32_t numFuncs = m_read.immU32();

    Vector<uint32_t> funcSigs(numFuncs);

    for (uint32_t i = 0; i != numFuncs; i++)

        funcSigs[i] = m_read.immU32();

    m_funcSigs = WTF::move(funcSigs);

}

void JITCompiler::readFunctionPointerTables()

{

    uint32_t numFuncPtrTables = m_read.immU32();

    Vector<FuncPtrTable> funcPtrTables(numFuncPtrTables);

    for (uint32_t i = 0; i != numFuncPtrTables; i++) {

        funcPtrTables[i].signatureIndex = m_read.immU32();

        uint32_t num_elements = m_read.immU32();

        Vector<uint32_t> elements(num_elements);

        for (uint32_t j = 0; j != num_elements; j++)

            elements[j] = m_read.immU32();

        funcPtrTables[i].elements = WTF::move(elements);

    }

    m_funcPtrTables = WTF::move(funcPtrTables);

}

void JITCompiler::readFunctionDefinitionSection()

{

    for (size_t i = 0; i < m_funcSigs.size(); i++)

        readFunctionDefinition(i);

}

void JITCompiler::readExportSection()

{

    switch (m_read.exportFormat()) {

        case ExportFormat::Default:

            m_read.immU32();

            break;

        case ExportFormat::Record:

            if (uint32_t num_exports = m_read.immU32()) {

                for (uint32_t export_index = 0;;) {

                    while (m_read.singleChar()) { }

                    m_read.immU32();

                    if (++export_index == num_exports)

                        break;

                }

            }

            break;

        default:

            RELEASE_ASSERT_NOT_REACHED();

    }

}

void JITCompiler::readFunctionDefinition(size_t funcIndex)

{

    const Signature& signature = m_signatures[m_funcSigs[funcIndex]];

    m_currentReturnType = signature.ret;

    m_currentLocalTypes.clear();

    readArgs(signature);

    readVars();

    stmt_list(0);

}

void JITCompiler::readArgs(const Signature& signature)

{

    size_t numArgs = signature.args.size();

    for (uint32_t argIndex = 0; argIndex < numArgs; argIndex++) {

        Type type = signature.args[argIndex];

        m_currentLocalTypes.append(type);

        switch (type) {

            case Type::I32:

            case Type::F32:

            case Type::F64:

                break;

            default:

                RELEASE_ASSERT_NOT_REACHED();

        }

    }

}

void JITCompiler::readVars()

{

    uint32_t numI32Vars = 0;

    uint32_t numF32Vars = 0;

    uint32_t numF64Vars = 0;

    VarTypes varTypes;

    VarTypesWithImm varTypesWithImm;

    uint8_t imm;

    if (m_read.code(&varTypes, &varTypesWithImm, &imm)) {

        if (varTypes & VarTypes::I32)

            numI32Vars = m_read.immU32();

        if (varTypes & VarTypes::F32)

            numF32Vars = m_read.immU32();

        if (varTypes & VarTypes::F64)

            numF64Vars = m_read.immU32();

    } else {

        numI32Vars = imm;

    }

    // FIXME: we need to initialize these to zeroes

    uint32_t num_vars = numI32Vars + numF32Vars + numF64Vars;

    if (num_vars > 0) {

        uint32_t localIndex = m_currentLocalTypes.size();

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

            m_currentLocalTypes.append(Type::I32);

            store32(TrustedImm32(0), stackAddress(localIndex++));

        }

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

            m_currentLocalTypes.append(Type::F32);

            store32(TrustedImm32(0), stackAddress(localIndex++)); // FIXME: float?

        }

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

            m_currentLocalTypes.append(Type::F64);

            store64(TrustedImm64(0), stackAddress(localIndex++)); // FIXME: float?

        }

    }

}

void JITCompiler::stmt(int dst)

{

    Stmt stmt;

    StmtWithImm stmtWithImm;

    uint8_t imm;

    if (m_read.code(&stmt, &stmtWithImm, &imm)) {

        switch (stmt) {

        case Stmt::SetLoc:

            set_local(dst);

            break;

        case Stmt::SetGlo:

        case Stmt::I32Store8:

        case Stmt::I32StoreOff8:

        case Stmt::I32Store16:

        case Stmt::I32StoreOff16:

        case Stmt::I32Store32:

        case Stmt::I32StoreOff32:

        case Stmt::F32Store:

        case Stmt::F32StoreOff:

        case Stmt::F64Store:

        case Stmt::F64StoreOff:

        case Stmt::CallInt:

        case Stmt::CallInd:

        case Stmt::CallImp:

            RELEASE_ASSERT_NOT_REACHED();

        case Stmt::Ret:

            return_stmt();

            return;

        case Stmt::Block:

            block_stmt(dst); return;

        case Stmt::IfThen:

            if_stmt(dst);

            return;

        case Stmt::IfElse:

            if_else_stmt(dst);

            return;

        case Stmt::While:

            while_stmt(dst);

            return;

        case Stmt::Do:

            do_stmt(dst);

            return;

        case Stmt::Label:

            label_stmt(dst);

            return;

        case Stmt::Break:

            topBreakJumpList()->append(jump());

            return;

        case Stmt::BreakLabel:

            break_label_stmt();

            return;

        case Stmt::Continue:

            topContinueJumpScope()->jump();

            break;

        case Stmt::ContinueLabel:

            continue_label_stmt();

            return;

        case Stmt::Switch:

            switch_stmt(dst);

            break;

        default:

            RELEASE_ASSERT_NOT_REACHED();

        }

    } else {

        switch (stmtWithImm) {

        case StmtWithImm::SetLoc:

            set_local(imm, dst);

            break;

        case StmtWithImm::SetGlo:

        default:

            RELEASE_ASSERT_NOT_REACHED();

        }

    }

}

void JITCompiler::get_local(int dst)

{

    // FIXME: type

    uint32_t imm = m_read.immU32();

    load32(stackAddress(imm), GPRInfo::regT0);

    store32(GPRInfo::regT0, temporaryAddress(dst));

}

void JITCompiler::set_local(uint32_t imm, int dst)

{

    Type type = m_currentLocalTypes[imm]; // FIXME: Should we receive the Type from the parent?

    expr(RType(type), dst);

    switch (type) {

        case Type::I32: {

            load32(temporaryAddress(dst), GPRInfo::regT0);

            store32(GPRInfo::regT0, stackAddress(imm));

            break;

        }

        case Type::F32:

        case Type::F64:

        default:

            RELEASE_ASSERT_NOT_REACHED();

    }

}

void JITCompiler::set_local(int dst)

{

    set_local(m_read.immU32(), dst);

}

void JITCompiler::return_stmt()

{

    // FIXME: hacky

    switch (m_currentReturnType) {

        case RType::I32:

            signed_expr(Signedness::Signed, 0);

            load32(temporaryAddress(0), GPRInfo::returnValueGPR);

            break;

        case RType::F32:

            expr(RType::F32, 0);

            load32(temporaryAddress(0), GPRInfo::returnValueGPR);

            break;

        case RType::F64:

            expr(RType::F64, 0);

            load64(temporaryAddress(0), GPRInfo::returnValueGPR);

            break;

        case RType::Void:

            break;

    }

}

void JITCompiler::stmt_list(int dst)

{

    uint32_t num_stmts = m_read.immU32();

    for (uint32_t i = 0; i < num_stmts; i++)

        stmt(dst);

}

void JITCompiler::block_stmt(int dst)

{

    stmt_list(dst);

}

void JITCompiler::if_stmt(int dst)

{

    expr(RType::I32, dst);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    Jump end = branchTest32(Zero, GPRInfo::regT0);

    stmt(dst);

    end.link(this);

}

void JITCompiler::if_else_stmt(int dst)

{

    expr(RType::I32, dst);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    Jump els = branchTest32(Zero, GPRInfo::regT0);

    stmt(dst);

    Jump end = jump();

    els.link(this);

    stmt(dst);

    end.link(this);

}

void JITCompiler::while_stmt(int dst)

{

    JumpScope continueJumpScope(this, label());

    pushContinueJumpScope(&continueJumpScope);

    JumpList breakJumpList;

    pushBreakJumpList(&breakJumpList);

    expr(RType::I32, dst);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    Jump end = branchTest32(Zero, GPRInfo::regT0);

    stmt(dst);

    continueJumpScope.jump();

    end.link(this);

    breakJumpList.link(this);

    popBreakJumpList();

    popContinueJumpScope();

}

void JITCompiler::do_stmt(int dst)

{

    JumpScope continueJumpScope(this);

    pushContinueJumpScope(&continueJumpScope);

    JumpList breakJumpList;

    pushBreakJumpList(&breakJumpList);

    Label start = label();

    stmt(dst);

    continueJumpScope.link();

    expr(RType::I32, dst);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    Jump jumpToStart = branchTest32(NonZero, GPRInfo::regT0);

    jumpToStart.linkTo(start, this);

    breakJumpList.link(this);

    popBreakJumpList();

    popContinueJumpScope();

}

void JITCompiler::label_stmt(int dst)

{

    Label continueLabel = label();

    JumpList breakJumpList;

    pushContinueLabelLabel(&continueLabel);

    pushBreakLabelJumpList(&breakJumpList);

    stmt(dst);

    breakJumpList.link(this);

    popBreakLabelJumpList();

    popContinueLabelLabel();

}

void JITCompiler::break_label_stmt()

{

    uint32_t index = m_read.immU32();

    breakLabelJumpList(index)->append(jump());

}

void JITCompiler::continue_label_stmt()

{

    uint32_t index = m_read.immU32();

    jump(*continueLabelLabel(index));

}

void JITCompiler::switch_stmt(int dst)

{

    JumpList breakJumpList;

    pushBreakJumpList(&breakJumpList);

    uint32_t numCases = m_read.immU32();

    signed_expr(Signedness::Signed, dst);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    Jump table = jump();

    Vector<Label> labels;

    Vector<int32_t> imms;

    Label defaultLabel;

    bool hasDefault = false;

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

        switch (m_read.switchCase()) {

            case SwitchCase::Case0:

                imms.append(m_read.immS32());

                labels.append(label());

                break;

            case SwitchCase::Case1:

                imms.append(m_read.immS32());

                labels.append(label());

                stmt(dst);

                break;

            case SwitchCase::CaseN:

                imms.append(m_read.immS32());

                labels.append(label());

                stmt_list(dst);

                break;

            case SwitchCase::Default0:

                defaultLabel = label();

                hasDefault = true;

                break;

            case SwitchCase::Default1:

                defaultLabel = label();

                hasDefault = true;

                stmt(dst);

                break;

            case SwitchCase::DefaultN:

                defaultLabel = label();

                hasDefault = true;

                stmt_list(dst);

                break;

            default:

                abort();

        }

    }

    Jump end = jump();

    table.link(this);

    for (size_t i = 0; i < labels.size(); ++i) {

        Jump j = branch32(Equal, GPRInfo::regT0, TrustedImm32(imms[i]));

        j.linkTo(labels[i], this);

    }

    if (hasDefault) {

        jump(defaultLabel);

    }

    end.link(this);

    breakJumpList.link(this);

    popBreakJumpList();

}

void JITCompiler::expr(RType rType, int dst)

{

    I32 i32;

    I32WithImm i32_with_imm;

    uint8_t imm;

    if (rType != RType::I32) {

        RELEASE_ASSERT_NOT_REACHED();

    }

    if (m_read.code(&i32, &i32_with_imm, &imm)) {

        switch (i32) {

            case I32::LitImm:

                store32(TrustedImm32(m_read.immU32()), temporaryAddress(dst));

                break;

            case I32::LitPool:

            case I32::GetLoc:

                get_local(dst); // TODO: should pass I32 as RType

                break;

            case I32::GetGlo:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::SetLoc:

                set_local(dst); // TODO: should pass I32 as RType

                break;

            case I32::SetGlo:

            case I32::SLoad8:

            case I32::SLoadOff8:

            case I32::ULoad8:

            case I32::ULoadOff8:

            case I32::SLoad16:

            case I32::SLoadOff16:

            case I32::ULoad16:

            case I32::ULoadOff16:

            case I32::Load32:

            case I32::LoadOff32:

            case I32::Store8:

            case I32::StoreOff8:

            case I32::Store16:

            case I32::StoreOff16:

            case I32::Store32:

            case I32::StoreOff32:

            case I32::CallInt:

            case I32::CallInd:

            case I32::CallImp:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::Cond:

                cond(RType::I32, dst);

                break;

            case I32::Comma:

                comma(RType::I32, dst);

                break;

            case I32::FromF32:

            case I32::FromF64:

            case I32::Neg:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::Add:

                add_sub('+', RType::I32, dst);

                break;

            case I32::Sub:

                add_sub('-', RType::I32, dst);

                break;

            case I32::Mul:

                mul_i32(dst);

                break;

            case I32::SDiv:

            case I32::UDiv:

            case I32::SMod:

            case I32::UMod:

            case I32::BitNot:

            case I32::BitOr:

            case I32::BitAnd:

            case I32::BitXor:

            case I32::Lsh:

            case I32::ArithRsh:

            case I32::LogicRsh:

            case I32::Clz:

            case I32::LogicNot:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::EqI32:

                rel_i32(Signedness::Signed, "==", dst);

                break;

            case I32::EqF32:

            case I32::EqF64:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::NEqI32:

                rel_i32(Signedness::Signed, "!=", dst);

                break;

            case I32::NEqF32:

            case I32::NEqF64:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::SLeThI32:

                rel_i32(Signedness::Signed, "<", dst);

                break;

            case I32::ULeThI32:

                rel_i32(Signedness::Unsigned, "<", dst);

                break;

            case I32::LeThF32:

            case I32::LeThF64:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::SLeEqI32:

                rel_i32(Signedness::Signed, "<=", dst);

                break;

            case I32::ULeEqI32:

                rel_i32(Signedness::Unsigned, "<=", dst);

                break;

            case I32::LeEqF32:

            case I32::LeEqF64:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::SGrThI32:

                rel_i32(Signedness::Signed, ">", dst);

                break;

            case I32::UGrThI32:

                rel_i32(Signedness::Unsigned, ">", dst);

                break;

            case I32::GrThF32:

            case I32::GrThF64:

                RELEASE_ASSERT_NOT_REACHED();

            case I32::SGrEqI32:

                rel_i32(Signedness::Signed, ">=", dst);

                break;

            case I32::UGrEqI32:

                rel_i32(Signedness::Unsigned, ">=", dst);

                break;

            case I32::GrEqF32:

            case I32::GrEqF64:

            case I32::SMin:

            case I32::UMin:

            case I32::SMax:

            case I32::UMax:

            case I32::Abs:

            default:

                RELEASE_ASSERT_NOT_REACHED();

        }

    } else {

        switch (i32_with_imm) {

            case I32WithImm::LitImm:

                store32(TrustedImm32(imm), temporaryAddress(dst));

                break;

            case I32WithImm::LitPool:

                store32(TrustedImm32(m_i32s[imm]), temporaryAddress(dst));

                break;

            case I32WithImm::GetLoc:

                load32(stackAddress(imm), GPRInfo::regT0);

                store32(GPRInfo::regT0, temporaryAddress(dst));

                break;

            default:

                RELEASE_ASSERT_NOT_REACHED();

        }

    }

}

void JITCompiler::signed_expr(Signedness signedness, int dst)

{

    uint32_t u32;

    if (m_read.ifI32Lit(m_i32s, &u32)) {

        if (signedness == Signedness::Signed) {

            store32(TrustedImm32(u32), temporaryAddress(dst));

        } else {

            store32(TrustedImm32(u32), temporaryAddress(dst)); // FIXME: unsigned

            //RELEASE_ASSERT_NOT_REACHED();

        }

    } else if (signedness == Signedness::Signed) {

        //expr<RType::I32>(Ctx::ToI32);

        //s.write().ascii("|0");

        expr(RType::I32, dst);

    } else {

        //expr<RType::I32>(Ctx::ToI32);

        //s.write().ascii(">>>0");

        expr(RType::I32, dst); // FIXME: unsigned

    }

}

void JITCompiler::add_sub(char op, RType rType, int dst)

{

    expr(rType, dst);

    expr(rType, dst + 1);

    if (op == '+') {

        load32(temporaryAddress(dst), GPRInfo::regT0);

        load32(temporaryAddress(dst + 1), GPRInfo::regT1);

        add32(GPRInfo::regT1, GPRInfo::regT0);

        store32(GPRInfo::regT0, temporaryAddress(dst));

    } else {

        load32(temporaryAddress(dst), GPRInfo::regT0);

        load32(temporaryAddress(dst + 1), GPRInfo::regT1);

        sub32(GPRInfo::regT1, GPRInfo::regT0);

        store32(GPRInfo::regT0, temporaryAddress(dst));

    }

}

void JITCompiler::mul_i32(int dst)

{

    expr(RType::I32, dst);

    expr(RType::I32, dst + 1);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    load32(temporaryAddress(dst + 1), GPRInfo::regT1);

    mul32(GPRInfo::regT1, GPRInfo::regT0);

    store32(GPRInfo::regT0, temporaryAddress(dst));

}

void JITCompiler::rel_i32(Signedness signedness, const char* op, int dst)

{

    signed_expr(signedness, dst);

    signed_expr(signedness, dst + 1);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    load32(temporaryAddress(dst + 1), GPRInfo::regT1);

    RelationalCondition condition;

    if (op[0] == '=' && op[1] == '=' && op[2] == 0) {

        condition = Equal;

    } else if (op[0] == '!' && op[1] == '=' && op[2] == 0) {

        condition = NotEqual;

    } else if (op[0] == '>' && op[1] == 0) {

        condition = GreaterThan;

    } else if (op[0] == '<' && op[1] == 0) {

        condition = LessThan;

    } else if (op[0] == '>' && op[1] == '=' && op[2] == 0) {

        condition = GreaterThanOrEqual;

    } else if (op[0] == '<' && op[1] == '=' && op[2] == 0) {

        condition = LessThanOrEqual;

    } else {

        RELEASE_ASSERT_NOT_REACHED();

    }

    compare32(condition, GPRInfo::regT0, GPRInfo::regT1, GPRInfo::regT0);

    store32(GPRInfo::regT0, temporaryAddress(dst));

}

void JITCompiler::comma(RType rType, int dst)

{

    expr(m_read.rtype(), dst);

    expr(rType, dst);

}

void JITCompiler::cond(RType rType, int dst)

{

    expr(RType::I32, dst);

    load32(temporaryAddress(dst), GPRInfo::regT0);

    Jump els = branchTest32(Zero, GPRInfo::regT0);

    expr(rType, dst);

    Jump end = jump();

    els.link(this);

    expr(rType, dst);

    end.link(this);

}

JSValue compileAndRun(ExecState* exec, const Vector<char>& buffer)

{

    JITCompiler compiler(&exec->vm());

    return compiler.compileAndRun(exec, buffer);

}

} } // namespace JSC::Wasm

/*

 * 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.

 */

#ifndef WasmJITCompiler_h

#define WasmJITCompiler_h

#include "AssemblyHelpers.h"

#include "WasmOpcodes.h"

namespace JSC {

class ExecState;

class JITCode;

class VM;

namespace Wasm {

class JumpScope;

class JITCompiler : private AssemblyHelpers {

public:

    JITCompiler(VM* vm) : AssemblyHelpers(vm, 0) { }

    JSValue compileAndRun(ExecState*, const Vector<char>& buffer);

private:

    struct FuncImportSignature {

        uint32_t signatureIndex;

        uint32_t funcImportIndex;

    };

    struct FuncPtrTable {

        uint32_t signatureIndex;

        Vector<uint32_t> elements;

    };

    RefPtr<JITCode> compile(VM&, const Vector<char>& buffer);

    void unpack();

    void readConstantPoolSection();

    void readSignatureSection();

    void readFunctionImportSection();

    void readGlobalSection();

    void readFunctionDeclarationSection();

    void readFunctionPointerTables();

    void readFunctionDefinitionSection();

    void readExportSection();

    void readFunctionDefinition(size_t funcIndex);

    void readArgs(const Signature&);

    void readVars();

    void stmt(int dst);

    void get_local(int dst);

    void set_local(uint32_t imm, int dst);

    void set_local(int dst);

    void return_stmt();

    void block_stmt(int dst);

    void stmt_list(int dst);

    void if_stmt(int dst);

    void if_else_stmt(int dst);

    void while_stmt(int dst);

    void do_stmt(int dst);

    void label_stmt(int dst);

    void break_label_stmt();

    void continue_label_stmt();

    void switch_stmt(int dst);

    void expr(RType rType, int dst);

    void signed_expr(Signedness, int dst);

    void add_sub(char op, RType, int dst);

    void mul_i32(int dst);

    void rel_i32(Signedness, const char* op, int dst);

    void comma(RType, int dst);

    void cond(RType, int dst);

    Address stackAddress(int i) { // FIXME:

        return Address(GPRInfo::callFrameRegister, -i * 8 - 8);

    }

    Address temporaryAddress(int i) { // FIXME:

        return Address(GPRInfo::callFrameRegister, -(i + m_currentLocalTypes.size()) * 8 - 8);

    }

    void pushContinueLabelLabel(Label* label) { m_continueLabelLabels.append(label); }

    void popContinueLabelLabel() { m_continueLabelLabels.removeLast(); }

    Label* continueLabelLabel(size_t i) const { return m_continueLabelLabels[i]; }

    void pushBreakLabelJumpList(JumpList* jumpList) { m_breakLabelJumpLists.append(jumpList); }

    void popBreakLabelJumpList() { m_breakLabelJumpLists.removeLast(); }

    JumpList* breakLabelJumpList(size_t i) const { return m_breakLabelJumpLists[i]; }

    void pushContinueJumpScope(JumpScope* jumpScope) { m_continueJumpScopes.append(jumpScope); }

    void popContinueJumpScope() { m_continueJumpScopes.removeLast(); }

    JumpScope* topContinueJumpScope() const { return m_continueJumpScopes.last(); }

    void pushBreakJumpList(JumpList* jumpList) { m_breakJumpLists.append(jumpList); }

    void popBreakJumpList() { m_breakJumpLists.removeLast(); }

    JumpList* topBreakJumpList() const { return m_breakJumpLists.last(); }

    In m_read;

    Vector<Signature> m_signatures;

    Vector<uint32_t> m_i32s;

    Vector<float> m_f32s;

    Vector<double> m_f64s;

    Vector<FuncImportSignature> m_funcImportSignatures;

    Vector<Type> m_globalTypes;

    Vector<uint32_t> m_funcSigs;

    Vector<FuncPtrTable> m_funcPtrTables;

    RType m_currentReturnType;

    Vector<Type> m_currentLocalTypes;

    Vector<MacroAssembler::Label*> m_continueLabelLabels;

    Vector<MacroAssembler::JumpList*> m_breakLabelJumpLists;

    Vector<JumpScope*> m_continueJumpScopes;

    Vector<MacroAssembler::JumpList*> m_breakJumpLists;

};

JS_EXPORT_PRIVATE JSValue compileAndRun(ExecState*, const Vector<char>& buffer);

} } // namespace JSC::Wasm

#endif // WasmJITCompiler_h

/*

 * 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.

 */

#ifndef WasmOpcodes_h

#define WasmOpcodes_h

namespace JSC {

namespace Wasm {

static const uint32_t MagicNumber = 0x6d736177;

enum class Stmt : uint8_t {

    SetLoc,

    SetGlo,

    I32Store8,

    I32StoreOff8,

    I32Store16,

    I32StoreOff16,

    I32Store32,

    I32StoreOff32,

    F32Store,

    F32StoreOff,

    F64Store,

    F64StoreOff,

    CallInt,

    CallInd,

    CallImp,

    Ret,

    Block,

    IfThen,

    IfElse,

    While,

    Do,

    Label,

    Break,

    BreakLabel,

    Continue,

    ContinueLabel,

    Switch,

    Bad

};

enum class StmtWithImm : uint8_t {

    SetLoc,

    SetGlo,

    Reseved1,

    Reseved2,

    Bad

};

enum class SwitchCase : uint8_t {

    Case0,

    Case1,

    CaseN,

    Default0,

    Default1,

    DefaultN

};

enum class I32 : uint8_t {

    LitPool,

    LitImm,

    GetLoc,

    GetGlo,

    SetLoc,

    SetGlo,

    SLoad8,

    SLoadOff8,

    ULoad8,

    ULoadOff8,

    SLoad16,

    SLoadOff16,

    ULoad16,

    ULoadOff16,

    Load32,

    LoadOff32,

    Store8,

    StoreOff8,

    Store16,

    StoreOff16,

    Store32,

    StoreOff32,

    CallInt,

    CallInd,

    CallImp,

    Cond,

    Comma,

    FromF32,

    FromF64,

    Neg,

    Add,

    Sub,

    Mul,

    SDiv,

    UDiv,

    SMod,

    UMod,

    BitNot,

    BitOr,

    BitAnd,

    BitXor,

    Lsh,

    ArithRsh,

    LogicRsh,

    Clz,

    LogicNot,

    EqI32,

    EqF32,

    EqF64,

    NEqI32,

    NEqF32,

    NEqF64,

    SLeThI32,

    ULeThI32,

    LeThF32,

    LeThF64,

    SLeEqI32,

    ULeEqI32,

    LeEqF32,

    LeEqF64,

    SGrThI32,

    UGrThI32,

    GrThF32,

    GrThF64,

    SGrEqI32,

    UGrEqI32,

    GrEqF32,

    GrEqF64,

    SMin,

    UMin,

    SMax,

    UMax,

    Abs,

    Bad

};

enum class I32WithImm : uint8_t {

    LitPool,

    LitImm,

    GetLoc,

    Reserved,

    Bad

};

enum class F32 : uint8_t {

    LitPool,

    LitImm,

    GetLoc,

    GetGlo,

    SetLoc,

    SetGlo,

    Load,

    LoadOff,

    Store,

    StoreOff,

    CallInt,

    CallInd,

    Cond,

    Comma,

    FromS32,

    FromU32,

    FromF64,

    Neg,

    Add,

    Sub,

    Mul,

    Div,

    Abs,

    Ceil,

    Floor,

    Sqrt,

    Bad

};

enum class F32WithImm : uint8_t {

    LitPool,

    GetLoc,

    Reserved0,

    Reserved1,

    Bad

};

enum class F64 : uint8_t {

    LitPool,

    LitImm,

    GetLoc,

    GetGlo,

    SetLoc,

    SetGlo,

    Load,

    LoadOff,

    Store,

    StoreOff,

    CallInt,

    CallInd,

    CallImp,

    Cond,

    Comma,

    FromS32,

    FromU32,

    FromF32,

    Neg,

    Add,

    Sub,

    Mul,

    Div,

    Mod,

    Min,

    Max,

    Abs,

    Ceil,

    Floor,

    Sqrt,

    Cos,

    Sin,

    Tan,

    ACos,

    ASin,

    ATan,

    ATan2,

    Exp,

    Ln,

    Pow,

    Bad

};

enum class F64WithImm : uint8_t {

    LitPool,

    GetLoc,

    Reserved0,

    Reserved1,

    Bad

};

enum class Void : uint8_t {

    CallInt,

    CallInd,

    CallImp,

    Bad

};

enum class Type : uint8_t {

    I32,

    F32,

    F64

};

enum class VarTypes : uint8_t {

    I32 = 0x1,

    F32 = 0x2,

    F64 = 0x4,

};

inline VarTypes operator|(VarTypes lhs, VarTypes rhs) { return VarTypes(uint8_t(lhs) | uint8_t(rhs)); }

inline bool operator&(VarTypes lhs, VarTypes rhs) { return bool(uint8_t(lhs) & uint8_t(rhs)); }

enum class VarTypesWithImm : uint8_t {

    OnlyI32,

    Reserved0,

    Reserved1,

    Reserved2

};

enum class RType : uint8_t {

    I32 = uint8_t(Type::I32),

    F32 = uint8_t(Type::F32),

    F64 = uint8_t(Type::F64),

    Void

};

class Expr {

public:

    Expr() : m_type(RType(-1)), u{} {}

    static Expr Bad() { return Expr(); }

    Expr(I32 i32) : m_type(RType::I32) { assert(i32 < I32::Bad); u.i32 = i32; }

    Expr(F32 f32) : m_type(RType::F32) { assert(f32 < F32::Bad); u.f32 = f32; }

    Expr(F64 f64) : m_type(RType::F64) { assert(f64 < F64::Bad); u.f64 = f64; }

    Expr(Void v) : m_type(RType::Void) { assert(v < Void::Bad); u.v = v; }

    bool is_bad() const { return m_type == RType(-1); }

    RType type() const { assert(!is_bad()); return m_type; }

    I32 i32() const { assert(m_type == RType::I32); return u.i32; }

    F32 f32() const { assert(m_type == RType::F32); return u.f32; }

    F64 f64() const { assert(m_type == RType::F64); return u.f64; }

    bool operator==(Expr rhs) const { return m_type == rhs.m_type && u.raw == rhs.u.raw; }

    bool operator!=(Expr rhs) const { return !(*this == rhs); }

private:

    RType m_type;

    union U {

        I32 i32;

        F32 f32;

        F64 f64;

        Void v;

        uint8_t raw;

    } u;

    static_assert(sizeof(U) == sizeof(uint8_t), "Exact overlay of raw_");

};

static const uint8_t HasImmFlag = 0x80;

static_assert(uint8_t(I32::Bad) <= HasImmFlag, "MSB reserved to distinguish I32 from I32WithImm");

static_assert(uint8_t(F32::Bad) <= HasImmFlag, "MSB reserved to distinguish F32 from F32WithImm");

static_assert(uint8_t(F64::Bad) <= HasImmFlag, "MSB reserved to distinguish F64 from F64WithImm");

static const unsigned OpWithImmBits = 2;

static const uint32_t OpWithImmLimit = 1 << OpWithImmBits;

static_assert(uint8_t(I32WithImm::Bad) <= OpWithImmLimit, "I32WithImm op fits");

static_assert(uint8_t(F32WithImm::Bad) <= OpWithImmLimit, "F32WithImm op fits");

static_assert(uint8_t(F64WithImm::Bad) <= OpWithImmLimit, "F64WithImm op fits");

static const unsigned ImmBits = 5;

static const uint32_t ImmLimit = 1 << ImmBits;

static_assert(1 + OpWithImmBits + ImmBits == 8, "Bits of immediate op should add up to a byte");

static inline uint8_t PackOpWithImm(uint8_t op, uint8_t imm)

{

    assert(op < OpWithImmLimit);

    assert(imm < ImmLimit);

    return HasImmFlag | (uint8_t(op) << ImmBits) | imm;

}

template <class TWithImm>

static inline void UnpackOpWithImm(uint8_t byte, TWithImm* op, uint8_t *imm)

{

    assert(byte & HasImmFlag);

    *op = TWithImm((byte >> ImmBits) & (OpWithImmLimit - 1));

    *imm = byte & (ImmLimit - 1);

}

class ExprWithImm {

public:

    ExprWithImm() : m_type(Type(-1)) {}

    ExprWithImm(I32WithImm i32) : m_type(Type::I32) { assert(i32 < I32WithImm::Bad); u.i32 = i32; }

    ExprWithImm(F32WithImm f32) : m_type(Type::F32) { assert(f32 < F32WithImm::Bad); u.f32 = f32; }

    ExprWithImm(F64WithImm f64) : m_type(Type::F64) { assert(f64 < F64WithImm::Bad); u.f64 = f64; }

    bool is_bad() const { return m_type == Type(-1); }

    Type type() const { return m_type; }

    I32WithImm i32() const { assert(m_type == Type::I32); return u.i32; }

    F32WithImm f32() const { assert(m_type == Type::F32); return u.f32; }

    F64WithImm f64() const { assert(m_type == Type::F64); return u.f64; }

private:

    Type m_type;

    union U {

        I32WithImm i32;

        F32WithImm f32;

        F64WithImm f64;

        uint8_t raw;

    } u;

    static_assert(sizeof(U) == sizeof(uint8_t), "Exact overlay of raw_");

};

enum class ExportFormat : uint8_t {

    Default,

    Record

};

enum class Signedness { Signed, Unsigned };

struct Signature {

    RType ret;

    Vector<Type> args;

    Signature() {}

    Signature(RType ret) : ret(ret) {}

    Signature(RType ret, uint32_t numArgs) : ret(ret), args(numArgs) {}

    Signature(RType ret, Vector<Type>&& args) : ret(ret), args(WTF::move(args)) {}

    bool operator==(const Signature& rhs) const { return ret == rhs.ret && args == rhs.args; }

    bool operator!=(const Signature& rhs) const { return !(*this == rhs); }

    struct Hash {

        bool operator()(const Signature &sig) const {

            static_assert(sizeof(Type) == 1 && sizeof(RType) == 1, "Shift more");

            uint32_t h = uint8_t(sig.ret);

            for (Type t : sig.args)

                h = ((h << 2) | uint8_t(t)) ^ (h >> 30);

            return h;

        }

    };

};

class In {

public:

    In() { }

    In(const uint8_t* begin) : m_cursor(begin) { }

    template <class T> T fixedWidth();

    Stmt stmt() { return u8<Stmt>(); }

    SwitchCase switchCase() { return u8<SwitchCase>(); }

    template<class T, class TWithImm> inline bool code(T*, TWithImm*, uint8_t*);

    Void voidExpr() { return u8<Void>(); }

    ExportFormat exportFormat() { return u8<ExportFormat>(); }

    Type type() { return u8<Type>(); }

    RType rtype() { return u8<RType>(); }

    inline uint32_t immU32();

    inline int32_t immS32();

    char singleChar() { return *m_cursor++; }

    inline bool ifI32Lit(const Vector<uint32_t>& i32s, uint32_t* u32);

private:

    template <class T> T u8() { return T(*m_cursor++); }

    const uint8_t* m_cursor;

};

template <>

inline uint32_t In::fixedWidth<uint32_t>()

{

    uint32_t u32 = m_cursor[0] | m_cursor[1] << 8 | m_cursor[2] << 16 | m_cursor[3] << 24;

    m_cursor += 4;

    return u32;

}

template <>

inline float In::fixedWidth<float>()

{

    union {

        uint8_t arr[4];

        float f;

    } u = { { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3] } };

    m_cursor += 4;

    return u.f;

}

template <>

inline double In::fixedWidth<double>()

{

    union {

        uint8_t arr[8];

        double d;

    } u = { { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3], m_cursor[4], m_cursor[5], m_cursor[6], m_cursor[7] } };

    m_cursor += 8;

    return u.d;

}

template <class T, class TWithImm>

bool In::code(T* t, TWithImm* tWithImm, uint8_t* imm)

{

    uint8_t byte = *m_cursor++;

    if (!(byte & HasImmFlag)) {

        *t = T(byte);

        return true;

    }

    UnpackOpWithImm(byte, tWithImm, imm);

    return false;

}

inline uint32_t In::immU32()

{

    uint32_t u32 = *m_cursor++;

    if (u32 < 0x80)

        return u32;

    u32 &= 0x7f;

    for (unsigned shift = 7; true; shift += 7) {

        uint32_t b = *m_cursor++;

        if (b < 0x80)

            return u32 | (b << shift);

        u32 |= (b & 0x7f) << shift;

    }

}

inline int32_t In::immS32()

{

    uint32_t u32 = *m_cursor++;

    if (u32 < 0x80)

        return int32_t(u32) << (32-7) >> (32-7);

    u32 &= 0x7f;

    for (unsigned shift = 7; true; shift += 7) {

        uint32_t b = *m_cursor++;

        if (b < 0x80) {

            u32 |= b << shift;

            int sign_extend = (32-7) - shift;

            if (sign_extend > 0)

                return int32_t(u32) << sign_extend >> sign_extend;

            return int32_t(u32);

        }

        u32 |= (b & 0x7f) << shift;

    }

}

inline bool In::ifI32Lit(const Vector<uint32_t>& i32s, uint32_t* u32)

{

    uint8_t byte = *m_cursor;

    if (byte & HasImmFlag) {

        I32WithImm i32WithImm;

        uint8_t imm;

        UnpackOpWithImm(byte, &i32WithImm, &imm);

        if (i32WithImm == I32WithImm::LitImm) {

            m_cursor++;

            *u32 = imm;

            return true;

        }

        if (i32WithImm == I32WithImm::LitPool) {

            m_cursor++;

            *u32 = i32s[imm];

            return true;

        }

        return false;

    }

    if (I32(byte) == I32::LitImm) {

        m_cursor++;

        *u32 = immU32();

        return true;

    }

    if (I32(byte) == I32::LitPool) {

        m_cursor++;

        *u32 = i32s[immU32()];

        return true;

    }

    return false;

}

} } // namespace JSC::Wasm

#endif // WasmOpcodes_h