//-------------------------------------------------------------------------------------------------------

// Copyright (C) Microsoft Corporation and contributors. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

#include "WasmReaderPch.h"

#ifdef ENABLE_WASM

#include "Language/WebAssemblySource.h"

#include "ByteCode/WasmByteCodeWriter.h"

#include "EmptyWasmByteCodeWriter.h"

#include "ByteCode/ByteCodeDumper.h"

#include "AsmJsByteCodeDumper.h"

#include "Language/InterpreterStackFrame.h"

#if DBG_DUMP

#define DebugPrintOp(op) if (DO_WASM_TRACE_BYTECODE) { PrintOpBegin(op); }

#define DebugPrintOpEnd() if (DO_WASM_TRACE_BYTECODE) { PrintOpEnd(); }

#else

#define DebugPrintOp(op)

#define DebugPrintOpEnd()

#endif

namespace Wasm

{

#define WASM_SIGNATURE(id, nTypes, ...) const WasmTypes::WasmType WasmOpCodeSignatures::id[] = {__VA_ARGS__};

#include "WasmBinaryOpCodes.h"

template<typename WriteFn>

void WasmBytecodeGenerator::WriteTypeStack(WriteFn writefn) const

{

writefn(_u("["));

int i = 0;

while (m_evalStack.Peek(i).type != WasmTypes::Limit)

{

++i;

}

--i;

bool isFirst = true;

while (i >= 0)

{

EmitInfo info = m_evalStack.Peek(i--);

if (!isFirst)

{

writefn(_u(", "));

}

isFirst = false;

writefn(GetTypeName(info.type));

}

writefn(_u("]"));

}

uint32 WasmBytecodeGenerator::WriteTypeStackToString(_Out_writes_(maxlen) char16* out, uint32 maxlen) const

{

AssertOrFailFast(out != nullptr);

uint32 numwritten = 0;

WriteTypeStack([&] (const char16* msg)

{

numwritten += _snwprintf_s(out + numwritten, maxlen - numwritten, _TRUNCATE, msg);

});

if (numwritten >= maxlen - 5)

{

// null out the last 5 characters so we can properly end it

for (int i = 1; i <= 5; i++)

{

*(out + maxlen - i) = 0;

}

numwritten -= 5;

numwritten += _snwprintf_s(out + numwritten, maxlen - numwritten, _TRUNCATE, _u("...]"));

}

return numwritten;

}

#if DBG_DUMP

void WasmBytecodeGenerator::PrintTypeStack() const

{

WriteTypeStack([](const char16* msg) { Output::Print(msg); });

}

void WasmBytecodeGenerator::PrintOpBegin(WasmOp op)

{

if (lastOpId == opId) Output::Print(_u("\r\n"));

lastOpId = ++opId;

const int depth = m_blockInfos.Count() - 1;

if (depth > 0)

{

Output::SkipToColumn(depth);

}

const auto PrintSignature = [this](uint32 sigId)

{

if (sigId < m_module->GetSignatureCount())

{

Output::Print(_u(" "));

WasmSignature* sig = m_module->GetSignature(sigId);

sig->Dump(64);

}

else

{

Output::Print(_u(" invalid signature id %u"), sigId);

}

};

switch (op)

{

#define WASM_OPCODE(opname, ...) \

case wb##opname: \

Output::Print(_u(#opname)); \

break;

#include "WasmBinaryOpCodes.h"

}

switch (op)

{

case wbIf:

case wbLoop:

case wbBlock:

if (GetReader()->m_currentNode.block.IsSingleResult())

{

Output::Print(_u(" () -> %s"), GetTypeName(GetReader()->m_currentNode.block.GetSingleResult()));

}

else

{

PrintSignature(GetReader()->m_currentNode.block.GetSignatureId()); break;

}

break;

case wbBr:

case wbBrIf: Output::Print(_u(" depth: %u"), GetReader()->m_currentNode.br.depth); break;

case wbBrTable: Output::Print(_u(" %u cases, default: %u"), GetReader()->m_currentNode.brTable.numTargets, GetReader()->m_currentNode.brTable.defaultTarget); break;

case wbCallIndirect: PrintSignature(GetReader()->m_currentNode.call.num); break;

case wbCall:

{

uint32 id = GetReader()->m_currentNode.call.num;

if (id < m_module->GetWasmFunctionCount())

{

FunctionIndexTypes::Type funcType = GetReader()->m_currentNode.call.funcType;

switch (funcType)

{

case Wasm::FunctionIndexTypes::Invalid: Output::Print(_u(" (invalid) ")); break;

case Wasm::FunctionIndexTypes::ImportThunk: Output::Print(_u(" (thunk) ")); break;

case Wasm::FunctionIndexTypes::Function: Output::Print(_u(" (func) ")); break;

case Wasm::FunctionIndexTypes::Import: Output::Print(_u(" (import) ")); break;

default: Output::Print(_u(" (unknown)")); break;

}

auto func = this->m_module->GetWasmFunctionInfo(id);

func->GetBody()->DumpFullFunctionName();

}

else

{

Output::Print(_u(" invalid id %u"), id);

}

break;

}

case wbSetLocal:

case wbGetLocal:

case wbTeeLocal:

case wbGetGlobal:

case wbSetGlobal: Output::Print(_u(" (%d)"), GetReader()->m_currentNode.var.num); break;

case wbI32Const: Output::Print(_u(" (%d, 0x%x)"), GetReader()->m_currentNode.cnst.i32, GetReader()->m_currentNode.cnst.i32); break;

case wbI64Const: Output::Print(_u(" (%lld, 0x%llx)"), GetReader()->m_currentNode.cnst.i64, GetReader()->m_currentNode.cnst.i64); break;

case wbF32Const: Output::Print(_u(" (%.4f)"), GetReader()->m_currentNode.cnst.f32); break;

case wbF64Const: Output::Print(_u(" (%.4f)"), GetReader()->m_currentNode.cnst.f64); break;

#define WASM_MEM_OPCODE(opname, ...) case wb##opname: // FallThrough

#include "WasmBinaryOpCodes.h"

{

const uint8 alignment = GetReader()->m_currentNode.mem.alignment;

const uint32 offset = GetReader()->m_currentNode.mem.offset;

switch (((!!alignment) << 1) | (!!offset))

{

case 0: // no alignment, no offset

Output::Print(_u(" [i]")); break;

case 1: // no alignment, offset

Output::Print(_u(" [i + %u (0x%x)]"), offset, offset); break;

case 2: // alignment, no offset

Output::Print(_u(" [i & ~0x%x]"), (1 << alignment) - 1); break;

case 3: // alignment, offset

Output::Print(_u(" [i + %u (0x%x) & ~0x%x]"), offset, offset, (1 << alignment) - 1); break;

}

break;

}

}

Output::SkipToColumn(40);

PrintTypeStack();

}

void WasmBytecodeGenerator::PrintOpEnd()

{

if (lastOpId == opId)

{

++opId;

Output::Print(_u(" -> "));

PrintTypeStack();

Output::Print(_u("\r\n"));

}

}

#endif

/* static */

Js::AsmJsRetType WasmToAsmJs::GetAsmJsReturnType(WasmTypes::WasmType wasmType)

{

switch (wasmType)

{

case WasmTypes::I32: return Js::AsmJsRetType::Signed;

case WasmTypes::I64: return Js::AsmJsRetType::Int64;

case WasmTypes::F32: return Js::AsmJsRetType::Float;

case WasmTypes::F64: return Js::AsmJsRetType::Double;

case WasmTypes::Void: return Js::AsmJsRetType::Void;

#ifdef ENABLE_WASM_SIMD

case WasmTypes::V128:

Simd::EnsureSimdIsEnabled();

return Js::AsmJsRetType::Float32x4;

#endif

default:

WasmTypes::CompileAssertCasesNoFailFast<WasmTypes::I32, WasmTypes::I64, WasmTypes::F32, WasmTypes::F64, WASM_V128_CHECK_TYPE>();

throw WasmCompilationException(_u("Unknown return type %u"), wasmType);

}

}

/* static */

Js::AsmJsVarType WasmToAsmJs::GetAsmJsVarType(WasmTypes::WasmType wasmType)

{

Js::AsmJsVarType asmType = Js::AsmJsVarType::Int;

switch (wasmType)

{

case WasmTypes::I32: return Js::AsmJsVarType::Int;

case WasmTypes::I64: return Js::AsmJsVarType::Int64;

case WasmTypes::F32: return Js::AsmJsVarType::Float;

case WasmTypes::F64: return Js::AsmJsVarType::Double;

#ifdef ENABLE_WASM_SIMD

case WasmTypes::V128:

Simd::EnsureSimdIsEnabled();

return Js::AsmJsVarType::Float32x4;

#endif

default:

WasmTypes::CompileAssertCasesNoFailFast<WasmTypes::I32, WasmTypes::I64, WasmTypes::F32, WasmTypes::F64, WASM_V128_CHECK_TYPE>();

throw WasmCompilationException(_u("Unknown var type %u"), wasmType);

}

}

typedef bool(*SectionProcessFunc)(WasmModuleGenerator*);

typedef void(*AfterSectionCallback)(WasmModuleGenerator*);

WasmModuleGenerator::WasmModuleGenerator(Js::ScriptContext* scriptContext, Js::WebAssemblySource* src) :

m_sourceInfo(src->GetSourceInfo()),

m_scriptContext(scriptContext),

m_recycler(scriptContext->GetRecycler())

{

m_module = RecyclerNewFinalized(m_recycler, Js::WebAssemblyModule, scriptContext, src->GetBuffer(), src->GetBufferLength(), scriptContext->GetLibrary()->GetWebAssemblyModuleType());

m_sourceInfo->EnsureInitialized(0);

m_sourceInfo->GetSrcInfo()->sourceContextInfo->EnsureInitialized();

}

Js::WebAssemblyModule* WasmModuleGenerator::GenerateModule()

{

Js::AutoProfilingPhase wasmPhase(m_scriptContext, Js::WasmReaderPhase);

Unused(wasmPhase);

m_module->GetReader()->InitializeReader();

BVStatic<bSectLimit + 1> visitedSections;

SectionCode nextExpectedSection = bSectCustom;

while (true)

{

SectionHeader sectionHeader = GetReader()->ReadNextSection();

SectionCode sectionCode = sectionHeader.code;

if (sectionCode == bSectLimit)

{

TRACE_WASM(PHASE_TRACE1(Js::WasmSectionPhase), _u("Done reading module's sections"));

break;

}

// Make sure dependency for this section has been seen

SectionCode precedent = SectionInfo::All[sectionCode].precedent;

if (precedent != bSectLimit && !visitedSections.Test(precedent))

{

throw WasmCompilationException(_u("%s section missing before %s"),

SectionInfo::All[precedent].name,

sectionHeader.name);

}

visitedSections.Set(sectionCode);

// Custom section are allowed in any order

if (sectionCode != bSectCustom)

{

if (sectionCode < nextExpectedSection)

{

throw WasmCompilationException(_u("Invalid Section %s"), sectionHeader.name);

}

nextExpectedSection = SectionCode(sectionCode + 1);

}

if (!GetReader()->ProcessCurrentSection())

{

throw WasmCompilationException(_u("Error while reading section %s"), sectionHeader.name);

}

}

uint32 funcCount = m_module->GetWasmFunctionCount();

SourceContextInfo * sourceContextInfo = m_sourceInfo->GetSrcInfo()->sourceContextInfo;

m_sourceInfo->EnsureInitialized(funcCount);

sourceContextInfo->nextLocalFunctionId += funcCount;

sourceContextInfo->EnsureInitialized();

for (uint32 i = 0; i < funcCount; ++i)

{

GenerateFunctionHeader(i);

}

#if ENABLE_DEBUG_CONFIG_OPTIONS

WasmFunctionInfo* firstThunk = nullptr, *lastThunk = nullptr;

for (uint32 i = 0; i < funcCount; ++i)

{

WasmFunctionInfo* info = m_module->GetWasmFunctionInfo(i);

Assert(info->GetBody());

if (PHASE_TRACE(Js::WasmInOutPhase, info->GetBody()))

{

uint32 index = m_module->GetWasmFunctionCount();

WasmFunctionInfo* newInfo = m_module->AddWasmFunctionInfo(info->GetSignature());

if (!firstThunk)

{

firstThunk = newInfo;

}

lastThunk = newInfo;

GenerateFunctionHeader(index);

m_module->SwapWasmFunctionInfo(i, index);

m_module->AttachCustomInOutTracingReader(newInfo, index);

}

}

if (firstThunk)

{

int sourceId = (int)firstThunk->GetBody()->GetSourceContextId();

char16 range[64];

swprintf_s(range, 64, _u("%d.%d-%d.%d"),

sourceId, firstThunk->GetBody()->GetLocalFunctionId(),

sourceId, lastThunk->GetBody()->GetLocalFunctionId());

char16 offFullJit[128];

swprintf_s(offFullJit, 128, _u("-off:fulljit:%s"), range);

char16 offSimpleJit[128];

swprintf_s(offSimpleJit, 128, _u("-off:simplejit:%s"), range);

char16 offLoopJit[128];

swprintf_s(offLoopJit, 128, _u("-off:jitloopbody:%s"), range);

char16* argv[] = { nullptr, offFullJit, offSimpleJit, offLoopJit };

CmdLineArgsParser parser(nullptr);

parser.Parse(ARRAYSIZE(argv), argv);

}

#endif

// If we see a FunctionSignatures section we need to see a FunctionBodies section

if (visitedSections.Test(bSectFunction) && !visitedSections.Test(bSectFunctionBodies))

{

throw WasmCompilationException(_u("Missing required section: %s"), SectionInfo::All[bSectFunctionBodies].name);

}

return m_module;

}

WasmBinaryReader* WasmModuleGenerator::GetReader() const

{

return m_module->GetReader();

}

void WasmModuleGenerator::GenerateFunctionHeader(uint32 index)

{

WasmFunctionInfo* wasmInfo = m_module->GetWasmFunctionInfo(index);

if (!wasmInfo)

{

throw WasmCompilationException(_u("Invalid function index %u"), index);

}

const char16* functionName = nullptr;

int nameLength = 0;

if (wasmInfo->GetNameLength() > 0)

{

functionName = wasmInfo->GetName();

nameLength = wasmInfo->GetNameLength();

}

else

{

for (uint32 iExport = 0; iExport < m_module->GetExportCount(); ++iExport)

{

Wasm::WasmExport* wasmExport = m_module->GetExport(iExport);

if (wasmExport &&

wasmExport->kind == ExternalKinds::Function &&

wasmExport->nameLength > 0 &&

m_module->GetFunctionIndexType(wasmExport->index) == FunctionIndexTypes::Function &&

wasmExport->index == wasmInfo->GetNumber())

{

nameLength = wasmExport->nameLength + 16;

char16 * autoName = RecyclerNewArrayLeafZ(m_recycler, char16, nameLength);

nameLength = swprintf_s(autoName, nameLength, _u("%s[%u]"), wasmExport->name, wasmInfo->GetNumber());

functionName = autoName;

break;

}

}

}

if (!functionName)

{

char16* autoName = RecyclerNewArrayLeafZ(m_recycler, char16, 32);

nameLength = swprintf_s(autoName, 32, _u("wasm-function[%u]"), wasmInfo->GetNumber());

functionName = autoName;

}

Js::FunctionBody* body = Js::FunctionBody::NewFromRecycler(

m_scriptContext,

functionName,

nameLength,

0,

0,

m_sourceInfo,

m_sourceInfo->GetSrcInfo()->sourceContextInfo->sourceContextId,

wasmInfo->GetNumber(),

Js::FunctionInfo::Attributes::ErrorOnNew,

Js::FunctionBody::Flags_None

#ifdef PERF_COUNTERS

, false /* is function from deferred deserialized proxy */

#endif

);

wasmInfo->SetBody(body);

// TODO (michhol): numbering

body->SetSourceInfo(0);

body->AllocateAsmJsFunctionInfo();

body->SetIsAsmJsFunction(true);

body->SetIsAsmjsMode(true);

body->SetIsWasmFunction(true);

WasmReaderInfo* readerInfo = RecyclerNew(m_recycler, WasmReaderInfo);

readerInfo->m_funcInfo = wasmInfo;

readerInfo->m_module = m_module;

Js::WasmLibrary::ResetFunctionBodyDefaultEntryPoint(body);

Js::AsmJsFunctionInfo* info = body->GetAsmJsFunctionInfo();

info->SetWasmReaderInfo(readerInfo);

info->SetWebAssemblyModule(m_module);

Js::ArgSlot paramCount = wasmInfo->GetParamCount();

info->SetArgCount(paramCount);

info->SetWasmSignature(wasmInfo->GetSignature());

Js::ArgSlot argSizeLength = max(paramCount, 3ui16);

info->SetArgSizeArrayLength(argSizeLength);

uint32* argSizeArray = RecyclerNewArrayLeafZ(m_recycler, uint32, argSizeLength);

info->SetArgsSizesArray(argSizeArray);

if (paramCount > 0)

{

// +1 here because asm.js includes the this pointer

body->SetInParamsCount(paramCount + 1);

body->SetReportedInParamsCount(paramCount + 1);

info->SetArgTypeArray(RecyclerNewArrayLeaf(m_recycler, Js::AsmJsVarType::Which, paramCount));

}

else

{

// overwrite default value in this case

body->SetHasImplicitArgIns(false);

}

for (Js::ArgSlot i = 0; i < paramCount; ++i)

{

WasmTypes::WasmType type = wasmInfo->GetSignature()->GetParam(i);

info->SetArgType(WasmToAsmJs::GetAsmJsVarType(type), i);

argSizeArray[i] = wasmInfo->GetSignature()->GetParamSize(i);

}

info->SetArgByteSize(wasmInfo->GetSignature()->GetParamsSize());

if (wasmInfo->GetSignature()->GetResultCount() <= 1)

{

WasmTypes::WasmType returnType = wasmInfo->GetSignature()->GetResultCount() == 1 ? wasmInfo->GetSignature()->GetResult(0) : WasmTypes::Void;

info->SetReturnType(WasmToAsmJs::GetAsmJsReturnType(returnType));

}

else

{

throw WasmCompilationException(_u("Multi return values not supported"));

}

}

WAsmJs::RegisterSpace* AllocateRegisterSpace(ArenaAllocator* alloc, WAsmJs::Types)

{

return Anew(alloc, WAsmJs::RegisterSpace, 1);

}

void WasmBytecodeGenerator::GenerateFunctionBytecode(Js::ScriptContext* scriptContext, WasmReaderInfo* readerinfo, bool validateOnly /*= false*/)

{

WasmBytecodeGenerator generator(scriptContext, readerinfo, validateOnly);

generator.GenerateFunction();

}

void WasmBytecodeGenerator::ValidateFunction(Js::ScriptContext* scriptContext, WasmReaderInfo* readerinfo)

{

GenerateFunctionBytecode(scriptContext, readerinfo, true);

}

WasmBytecodeGenerator::WasmBytecodeGenerator(Js::ScriptContext* scriptContext, WasmReaderInfo* readerInfo, bool validateOnly) :

m_scriptContext(scriptContext),

m_alloc(_u("WasmBytecodeGen"), scriptContext->GetThreadContext()->GetPageAllocator(), Js::Throw::OutOfMemory),

m_evalStack(&m_alloc),

mTypedRegisterAllocator(&m_alloc, AllocateRegisterSpace, Simd::IsEnabled() ? 0 : 1 << WAsmJs::SIMD),

m_blockInfos(&m_alloc),

currentProfileId(0),

isUnreachable(false)

{

m_emptyWriter = Anew(&m_alloc, Js::EmptyWasmByteCodeWriter);

m_writer = m_originalWriter = validateOnly ? m_emptyWriter : Anew(&m_alloc, Js::WasmByteCodeWriter);

m_writer->Create();

m_funcInfo = readerInfo->m_funcInfo;

m_module = readerInfo->m_module;

// Init reader to current func offset

GetReader()->SeekToFunctionBody(m_funcInfo);

const uint32 estimated = GetReader()->EstimateCurrentFunctionBytecodeSize();

m_writer->InitData(&m_alloc, estimated);

}

void WasmBytecodeGenerator::GenerateFunction()

{

#ifdef ENABLE_DEBUG_CONFIG_OPTIONS

if (DO_WASM_TRACE_BYTECODE)

{

Output::Print(_u("Generate WebAssembly Bytecode: "));

GetFunctionBody()->DumpFullFunctionName();

Output::Print(_u("\n"));

}

#endif

if (PHASE_OFF(Js::WasmBytecodePhase, GetFunctionBody()))

{

throw WasmCompilationException(_u("Compilation skipped"));

}

Js::AutoProfilingPhase functionProfiler(m_scriptContext, Js::WasmBytecodePhase);

Unused(functionProfiler);

m_maxArgOutDepth = 0;

m_writer->Begin(GetFunctionBody(), &m_alloc);

struct AutoCleanupGeneratorState

{

WasmBytecodeGenerator* gen;

AutoCleanupGeneratorState(WasmBytecodeGenerator* gen) : gen(gen) {}

~AutoCleanupGeneratorState()

{

if (gen)

{

TRACE_WASM(PHASE_TRACE(Js::WasmBytecodePhase, gen->GetFunctionBody()), _u("\nHad Compilation error!"));

gen->GetReader()->FunctionEnd();

gen->m_originalWriter->Reset();

}

}

void Complete()

{

gen->m_writer->End();

gen->GetReader()->FunctionEnd();

gen = nullptr;

}

};

AutoCleanupGeneratorState autoCleanupGeneratorState(this);

Js::ByteCodeLabel exitLabel = m_writer->DefineLabel();

m_funcInfo->SetExitLabel(exitLabel);

EnregisterLocals();

// The function's yield type is the return type

Js::ByteCodeLabel blockLabel = m_writer->DefineLabel();

WasmBlock funcBlockData;

funcBlockData.SetSignatureId(m_funcInfo->GetSignature()->GetSignatureId());

m_funcBlock = PushLabel(funcBlockData, blockLabel, true, false);

EnterEvalStackScope(m_funcBlock);

EmitBlockCommon(m_funcBlock);

m_writer->MarkAsmJsLabel(blockLabel);

PolymorphicEmitInfo yieldInfo = PopLabel(blockLabel);

if (yieldInfo.Count() > 0 || m_funcInfo->GetResultCount() == 0)

{

EmitReturnExpr(&yieldInfo);

}

DebugPrintOpEnd();

ExitEvalStackScope(m_funcBlock);

SetUnreachableState(false);

m_writer->MarkAsmJsLabel(exitLabel);

m_writer->EmptyAsm(Js::OpCodeAsmJs::Ret);

m_writer->SetCallSiteCount(this->currentProfileId);

if (!GetReader()->IsCurrentFunctionCompleted())

{

throw WasmCompilationException(_u("Invalid function format"));

}

autoCleanupGeneratorState.Complete();

// Make sure we don't have any unforeseen exceptions as we finalize the body

AutoDisableInterrupt autoDisableInterrupt(m_scriptContext->GetThreadContext(), true);

#if DBG_DUMP

if ((

PHASE_DUMP(Js::WasmBytecodePhase, GetFunctionBody()) ||

PHASE_DUMP(Js::ByteCodePhase, GetFunctionBody())

) && !IsValidating())

{

Js::AsmJsByteCodeDumper::Dump(GetFunctionBody(), &mTypedRegisterAllocator, nullptr);

}

if (PHASE_DUMP(Js::WasmOpCodeDistributionPhase, GetFunctionBody()))

{

m_module->GetReader()->PrintOps();

}

#endif

Js::AsmJsFunctionInfo* info = GetFunctionBody()->GetAsmJsFunctionInfo();

mTypedRegisterAllocator.CommitToFunctionBody(GetFunctionBody());

mTypedRegisterAllocator.CommitToFunctionInfo(info, GetFunctionBody());

GetFunctionBody()->CheckAndSetOutParamMaxDepth(m_maxArgOutDepth);

autoDisableInterrupt.Completed();

}

void WasmBytecodeGenerator::EnregisterLocals()

{

uint32 nLocals = m_funcInfo->GetLocalCount();

m_locals = AnewArray(&m_alloc, WasmLocal, nLocals);

m_funcInfo->GetBody()->SetFirstTmpReg(nLocals);

for (uint32 i = 0; i < nLocals; ++i)

{

WasmTypes::WasmType type = m_funcInfo->GetLocal(i);

WasmRegisterSpace* regSpace = GetRegisterSpace(type);

m_locals[i] = WasmLocal(regSpace->AcquireRegister(), type);

// Zero only the locals not corresponding to formal parameters.

if (i >= m_funcInfo->GetParamCount()) {

switch (type)

{

case WasmTypes::F32:

m_writer->AsmFloat1Const1(Js::OpCodeAsmJs::Ld_FltConst, m_locals[i].location, 0.0f);

break;

case WasmTypes::F64:

m_writer->AsmDouble1Const1(Js::OpCodeAsmJs::Ld_DbConst, m_locals[i].location, 0.0);

break;

case WasmTypes::I32:

m_writer->AsmInt1Const1(Js::OpCodeAsmJs::Ld_IntConst, m_locals[i].location, 0);

break;

case WasmTypes::I64:

m_writer->AsmLong1Const1(Js::OpCodeAsmJs::Ld_LongConst, m_locals[i].location, 0);

break;

#ifdef ENABLE_WASM_SIMD

case WasmTypes::V128:

{

Simd::EnsureSimdIsEnabled();

m_writer->WasmSimdConst(Js::OpCodeAsmJs::Simd128_LdC, m_locals[i].location, 0, 0, 0, 0);

break;

}

#endif

default:

Assume(UNREACHED);

}

}

}

}

void WasmBytecodeGenerator::EmitExpr(WasmOp op)

{

DebugPrintOp(op);

switch (op)

{

#define WASM_OPCODE(opname, opcode, sig, imp, wat) \

case opcode: \

if (!imp) throw WasmCompilationException(_u("Operator %s is Not Yet Implemented"), _u(wat)); break;

#include "WasmBinaryOpCodes.h"

default:

break;

}

PolymorphicEmitInfo info;

switch (op)

{

case wbGetGlobal:

info = EmitGetGlobal();

break;

case wbSetGlobal:

info = EmitSetGlobal();

break;

case wbGetLocal:

info = EmitGetLocal();

break;

case wbSetLocal:

info = EmitSetLocal(false);

break;

case wbTeeLocal:

info = EmitSetLocal(true);

break;

case wbReturn:

EmitReturnExpr();

info = EmitInfo(WasmTypes::Any);

break;

case wbF32Const:

info = EmitConst(WasmTypes::F32, GetReader()->m_currentNode.cnst);

break;

case wbF64Const:

info = EmitConst(WasmTypes::F64, GetReader()->m_currentNode.cnst);

break;

case wbI32Const:

info = EmitConst(WasmTypes::I32, GetReader()->m_currentNode.cnst);

break;

case wbI64Const:

info = EmitConst(WasmTypes::I64, GetReader()->m_currentNode.cnst);

break;

#ifdef ENABLE_WASM_SIMD

case wbV128Const:

Simd::EnsureSimdIsEnabled();

info = EmitConst(WasmTypes::V128, GetReader()->m_currentNode.cnst);

break;

#endif

case wbBlock:

info = EmitBlock();

break;

case wbLoop:

info = EmitLoop();

break;

case wbCall:

info = EmitCall<wbCall>();

break;

case wbCallIndirect:

info = EmitCall<wbCallIndirect>();

break;

case wbIf:

info = EmitIfElseExpr();

break;

case wbElse:

throw WasmCompilationException(_u("Unexpected else opcode"));

case wbEnd:

throw WasmCompilationException(_u("Unexpected end opcode"));

case wbBr:

EmitBr();

info = EmitInfo(WasmTypes::Any);

break;

case wbBrIf:

info = EmitBrIf();

break;

case wbSelect:

info = EmitSelect();

break;

case wbBrTable:

EmitBrTable();

info = EmitInfo(WasmTypes::Any);

break;

case wbDrop:

info = EmitDrop();

break;

case wbNop:

return;

case wbMemorySize:

{

SetUsesMemory(0);

Js::RegSlot tempReg = GetRegisterSpace(WasmTypes::I32)->AcquireTmpRegister();

info = EmitInfo(tempReg, WasmTypes::I32);

m_writer->AsmReg1(Js::OpCodeAsmJs::MemorySize_Int, tempReg);

break;

}

case wbMemoryGrow:

{

info = EmitGrowMemory();

break;

}

case wbUnreachable:

m_writer->EmptyAsm(Js::OpCodeAsmJs::Unreachable_Void);

SetUnreachableState(true);

info = EmitInfo(WasmTypes::Any);

break;

#ifdef ENABLE_WASM_SIMD

case wbV128Bitselect:

Simd::EnsureSimdIsEnabled();

info = EmitV128BitSelect();

break;

case wbV8X16Shuffle:

Simd::EnsureSimdIsEnabled();

info = EmitV8X16Shuffle();

break;

#define WASM_EXTRACTLANE_OPCODE(opname, opcode, sig, asmjsop, ...) \

case wb##opname: \

Simd::EnsureSimdIsEnabled();\

info = EmitExtractLaneExpr(Js::OpCodeAsmJs::##asmjsop, WasmOpCodeSignatures::sig); \

break;

#define WASM_REPLACELANE_OPCODE(opname, opcode, sig, asmjsop, ...) \

case wb##opname: \

Simd::EnsureSimdIsEnabled();\

info = EmitReplaceLaneExpr(Js::OpCodeAsmJs::##asmjsop, WasmOpCodeSignatures::sig); \

break;

#endif

#define WASM_MEMREAD_OPCODE(opname, opcode, sig, imp, viewtype, wat) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig > 0);\

info = EmitMemAccess<false, false>(wb##opname, WasmOpCodeSignatures::sig, viewtype); \

break;

#define WASM_ATOMICREAD_OPCODE(opname, opcode, sig, imp, viewtype, wat) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig > 0);\

info = EmitMemAccess<false, true>(wb##opname, WasmOpCodeSignatures::sig, viewtype); \

break;

#define WASM_MEMSTORE_OPCODE(opname, opcode, sig, imp, viewtype, wat) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig > 0);\

info = EmitMemAccess<true, false>(wb##opname, WasmOpCodeSignatures::sig, viewtype); \

break;

#define WASM_ATOMICSTORE_OPCODE(opname, opcode, sig, imp, viewtype, wat) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig > 0);\

info = EmitMemAccess<true, true>(wb##opname, WasmOpCodeSignatures::sig, viewtype); \

break;

#define WASM_SIMD_MEMREAD_OPCODE(opname, opcode, sig, asmjsop, viewtype, dataWidth, ...) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig > 0);\

info = EmitSimdMemAccess(Js::OpCodeAsmJs::##asmjsop, WasmOpCodeSignatures::sig, viewtype, dataWidth, false); \

break;

#define WASM_SIMD_MEMSTORE_OPCODE(opname, opcode, sig, asmjsop, viewtype, dataWidth, ...) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig > 0);\

info = EmitSimdMemAccess(Js::OpCodeAsmJs::##asmjsop, WasmOpCodeSignatures::sig, viewtype, dataWidth, true); \

break;

#define WASM_BINARY_OPCODE(opname, opcode, sig, asmjsop, imp, wat) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig == 3);\

info = EmitBinExpr(Js::OpCodeAsmJs::##asmjsop, WasmOpCodeSignatures::sig); \

break;

#define WASM_UNARY__OPCODE(opname, opcode, sig, asmjsop, imp, wat) \

case wb##opname: \

Assert(WasmOpCodeSignatures::n##sig == 2);\

info = EmitUnaryExpr(Js::OpCodeAsmJs::##asmjsop, WasmOpCodeSignatures::sig); \

break;

#define WASM_EMPTY__OPCODE(opname, opcode, asmjsop, imp, wat) \

case wb##opname: \

m_writer->EmptyAsm(Js::OpCodeAsmJs::##asmjsop);\

break;

#include "WasmBinaryOpCodes.h"

default:

throw WasmCompilationException(_u("Unknown expression's op 0x%X"), op);

}

PushEvalStack(info);

DebugPrintOpEnd();

}

EmitInfo WasmBytecodeGenerator::EmitGetGlobal()

{

uint32 globalIndex = GetReader()->m_currentNode.var.num;

WasmGlobal* global = m_module->GetGlobal(globalIndex);

WasmTypes::WasmType type = global->GetType();

Js::RegSlot slot = m_module->GetOffsetForGlobal(global);

CompileAssert(WasmTypes::I32 == 1);

CompileAssert(WasmTypes::I64 == 2);

CompileAssert(WasmTypes::F32 == 3);

CompileAssert(WasmTypes::F64 == 4);

static const Js::OpCodeAsmJs globalOpcodes[] = {

Js::OpCodeAsmJs::LdSlot_Int,

Js::OpCodeAsmJs::LdSlot_Long,

Js::OpCodeAsmJs::LdSlot_Flt,

Js::OpCodeAsmJs::LdSlot_Db

};

WasmRegisterSpace* regSpace = GetRegisterSpace(type);

Js::RegSlot tmpReg = regSpace->AcquireTmpRegister();

EmitInfo info(tmpReg, type);

m_writer->AsmSlot(globalOpcodes[type - 1], tmpReg, WasmBytecodeGenerator::ModuleEnvRegister, slot);

return info;

}

EmitInfo WasmBytecodeGenerator::EmitSetGlobal()

{

uint32 globalIndex = GetReader()->m_currentNode.var.num;

WasmGlobal* global = m_module->GetGlobal(globalIndex);

Js::RegSlot slot = m_module->GetOffsetForGlobal(global);

WasmTypes::WasmType type = global->GetType();

EmitInfo info = PopEvalStack(type);

CompileAssert(WasmTypes::I32 == 1);

CompileAssert(WasmTypes::I64 == 2);

CompileAssert(WasmTypes::F32 == 3);

CompileAssert(WasmTypes::F64 == 4);

static const Js::OpCodeAsmJs globalOpcodes[] = {

Js::OpCodeAsmJs::StSlot_Int,

Js::OpCodeAsmJs::StSlot_Long,

Js::OpCodeAsmJs::StSlot_Flt,

Js::OpCodeAsmJs::StSlot_Db

};

m_writer->AsmSlot(globalOpcodes[type - 1], info.location, WasmBytecodeGenerator::ModuleEnvRegister, slot);

ReleaseLocation(&info);

return EmitInfo();

}

EmitInfo WasmBytecodeGenerator::EmitGetLocal()

{

uint32 localIndex = GetReader()->m_currentNode.var.num;

if (m_funcInfo->GetLocalCount() <= localIndex)

{

throw WasmCompilationException(_u("%u is not a valid local"), localIndex);

}

WasmLocal local = m_locals[localIndex];

Js::OpCodeAsmJs op = GetLoadOp(local.type);

WasmRegisterSpace* regSpace = GetRegisterSpace(local.type);

Js::RegSlot tmpReg = regSpace->AcquireTmpRegister();

m_writer->AsmReg2(op, tmpReg, local.location);

return EmitInfo(tmpReg, local.type);

}

EmitInfo WasmBytecodeGenerator::EmitSetLocal(bool tee)

{

uint32 localNum = GetReader()->m_currentNode.var.num;

if (localNum >= m_funcInfo->GetLocalCount())

{

throw WasmCompilationException(_u("%u is not a valid local"), localNum);

}

WasmLocal local = m_locals[localNum];

EmitInfo info = PopEvalStack(local.type);

m_writer->AsmReg2(GetLoadOp(local.type), local.location, info.location);

if (tee)

{

if (info.type == WasmTypes::Any)

{

info.location = local.location;

info.type = local.type;

}

return info;

}

else

{

ReleaseLocation(&info);

return EmitInfo();

}

}

EmitInfo WasmBytecodeGenerator::EmitConst(WasmTypes::WasmType type, WasmConstLitNode cnst)

{

Js::RegSlot tmpReg = GetRegisterSpace(type)->AcquireTmpRegister();

EmitInfo dst(tmpReg, type);

EmitLoadConst(dst, cnst);

return dst;

}

void WasmBytecodeGenerator::EmitLoadConst(EmitInfo dst, WasmConstLitNode cnst)

{

switch (dst.type)

{

case WasmTypes::F32:

m_writer->AsmFloat1Const1(Js::OpCodeAsmJs::Ld_FltConst, dst.location, cnst.f32);

break;

case WasmTypes::F64:

m_writer->AsmDouble1Const1(Js::OpCodeAsmJs::Ld_DbConst, dst.location, cnst.f64);

break;

case WasmTypes::I32:

m_writer->AsmInt1Const1(Js::OpCodeAsmJs::Ld_IntConst, dst.location, cnst.i32);

break;

case WasmTypes::I64:

m_writer->AsmLong1Const1(Js::OpCodeAsmJs::Ld_LongConst, dst.location, cnst.i64);

break;

#ifdef ENABLE_WASM_SIMD

case WasmTypes::V128:

{

Simd::EnsureSimdIsEnabled();

m_writer->WasmSimdConst(Js::OpCodeAsmJs::Simd128_LdC, dst.location, cnst.v128[0], cnst.v128[1], cnst.v128[2], cnst.v128[3]);

break;

}

#endif

default:

WasmTypes::CompileAssertCasesNoFailFast<WasmTypes::I32, WasmTypes::I64, WasmTypes::F32, WasmTypes::F64, WASM_V128_CHECK_TYPE>();

throw WasmCompilationException(_u("Unknown type %u"), dst.type);

}

}

WasmConstLitNode WasmBytecodeGenerator::GetZeroCnst()

{

WasmConstLitNode cnst = {0};

return cnst;

}

void WasmBytecodeGenerator::EnsureStackAvailable()

{

if (!ThreadContext::IsCurrentStackAvailable(Js::Constants::MinStackCompile))

{

throw WasmCompilationException(_u("Maximum supported nested blocks reached"));

}

}

void WasmBytecodeGenerator::EmitBlockCommon(BlockInfo* blockInfo, bool* endOnElse /*= nullptr*/)

{

EnsureStackAvailable();

bool canResetUnreachable = !IsUnreachable();

WasmOp op;

EnterEvalStackScope(blockInfo);

if(endOnElse) *endOnElse = false;