int index;

if (ast[0] == BLOCK || ast[0] == TOPLEVEL) {

index = 1;

} else if (ast[0] == DEFUN) {

index = 3;

} else {

abort();

}

if (extra->isArray() && extra[0] == BLOCK) {

for (size_t i = 0; i < extra[1]->size(); i++) {

ast[index]->push_back(extra[1][i]);

}

} else {

ast[index]->push_back(extra);

}

if (!ast.get()) {

ast = extra;

return;

}

ast = ValueBuilder::makeSeq(ast, extra);

if (wasm.tables.empty() || wasm.tables[0]->imported()) {

return false;

}

for (auto& ex : wasm.exports) {

if (ex->kind == ExternalKind::Table &&

*ex->getInternalName() == wasm.tables[0]->name) {

return true;

}

}

return false;

for (Index i = 0; i < wasm.dataSegments.size(); i++) {

if (!wasm.dataSegments[i]->isPassive) {

return true;

}

}

return false;

if (wasm.memories.empty()) {

return false;

}

// If there are any active segments, initActiveSegments needs access

// to bufferView.

if (hasActiveSegments(wasm)) {

return true;

}

// The special support functions are emitted as part of the JS glue, if we

// need them.

bool need = false;

ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) {

if (ABI::wasm2js::isHelper(import->base)) {

need = true;

}

});

return need;

Export,

Top,

Local,

Label,

Max,

struct Flags {

// see wasm2js.cpp for details

bool debug = false;

bool pedantic = false;

bool allowAsserts = false;

bool emscripten = false;

bool deterministic = false;

std::string symbolsFile;

};

// Map data segment names to indices.

std::unordered_map<Name, Index> dataIndices;

Wasm2JSBuilder(Flags f, PassOptions options_) : flags(f), options(options_) {

// We don't try to model wasm's trapping precisely - if we did, each load

// and store would need to do a check. Given that, we can just ignore

// implicit traps like those when optimizing. (When not optimizing, it's

// nice to see codegen that matches wasm more precisely.)

// It is also important to prevent the optimizer from adding new things that

// require additional lowering, as we could hit a cycle.

if (options.optimizeLevel > 0) {

options.ignoreImplicitTraps = true;

options.targetJS = true;

}

}

Ref processWasm(Module* wasm, Name funcName = ASM_FUNC);

Ref processFunction(Module* wasm, Function* func, bool standalone = false);

Ref processStandaloneFunction(Module* wasm, Function* func) {

return processFunction(wasm, func, true);

}

// The second pass on an expression: process it fully, generating

// JS

Ref processExpression(Expression* curr,

Module* m,

Function* func = nullptr,

bool standalone = false);

Index getDataIndex(Name segment) {

auto it = dataIndices.find(segment);

assert(it != dataIndices.end());

return it->second;

}

// Get a temp var.

IString getTemp(Type type, Function* func) {

IString ret;

// TODO: handle tuples

assert(!type.isTuple() && "Unexpected tuple type");

if (frees[type].size() > 0) {

ret = frees[type].back();

frees[type].pop_back();

} else {

auto index = temps[type]++;

ret = IString((std::string("wasm2js_") + type.toString() + "$" +

std::to_string(index))

.c_str(),

false);

ret = fromName(ret, NameScope::Local);

}

if (func->localIndices.find(ret) == func->localIndices.end()) {

Builder::addVar(func, ret, type);

}

return ret;

}

// Free a temp var.

void freeTemp(Type type, IString temp) {

// TODO: handle tuples

assert(!type.isTuple() && "Unexpected tuple type");

frees[type].push_back(temp);

}

// Generates a mangled name from `name` within the specified scope.

//

// The goal of this function is to ensure that all identifiers in JS ar

// unique. Otherwise there can be clashes with locals and functions and cause

// unwanted name shadowing.

//

// The returned string from this function is constant for a particular `name`

// within a `scope`. Or in other words, the same `name` and `scope` pair will

// always return the same result. If `scope` changes, however, the return

// value may differ even if the same `name` is passed in.

IString fromName(Name name, NameScope scope) {

// TODO: checking names do not collide after mangling

// First up check our cached of mangled names to avoid doing extra work

// below

auto& map = wasmNameToMangledName[(int)scope];

auto it = map.find(name.str.data());

if (it != map.end()) {

return it->second;

}

// The mangled names in our scope.

auto& scopeMangledNames = mangledNames[(int)scope];

// In some cases (see below) we need to also check the Top scope.

auto& topMangledNames = mangledNames[int(NameScope::Top)];

// This is the first time we've seen the `name` and `scope` pair. Generate a

// globally unique name based on `name` and then register that in our cache

// and return it.

//

// Identifiers here generated are of the form `${name}_${n}` where `_${n}`

// is omitted if `n==0` and otherwise `n` is just looped over to find the

// next unused identifier.

IString ret;

for (int i = 0;; i++) {

std::ostringstream out;

out << name;

if (i > 0) {

out << "_" << i;

}

auto mangled = asmangle(out.str());

ret = stringToIString(mangled);

if (scopeMangledNames.count(ret)) {

// When export names collide things may be confusing, as this is

// observable externally by the person using the JS. Report a warning.

if (scope == NameScope::Export) {

std::cerr << "wasm2js: warning: export names colliding: " << mangled

<< '\n';

}

continue;

}

// The Local scope is special: a Local name must not collide with a Top

// name, as they are in a single namespace in JS and can conflict:

//

// function foo(bar) {

// var bar = 0;

// }

// function bar() { ..

if (scope == NameScope::Local && topMangledNames.count(ret)) {

continue;

}

// We found a good name, use it.

scopeMangledNames.insert(ret);

map[name.str.data()] = ret;

return ret;

}

}

Flags flags;

PassOptions options;

// How many temp vars we need for each type (type => num).

std::unordered_map<Type, Index> temps;

// Which temp vars are currently free to use for each type (type => freelist).

std::unordered_map<Type, std::vector<IString>> frees;

// Mangled names cache by interned names.

// Utilizes the usually reused underlying cstring's pointer as the key.

std::unordered_map<const void*, IString>

wasmNameToMangledName[(int)NameScope::Max];

// Set of all mangled names in each scope.

std::unordered_set<IString> mangledNames[(int)NameScope::Max];

std::unordered_set<IString> seenModuleImports;

// If a function is callable from outside, we'll need to cast the inputs

// and our return value. Otherwise, internally, casts are only needed

// on operations.

std::unordered_set<Name> functionsCallableFromOutside;

void ensureModuleVar(Ref ast, const Importable& imp);

Ref getImportName(const Importable& imp);

void addBasics(Ref ast, Module* wasm);

void addFunctionImport(Ref ast, Function* import);

void addGlobalImport(Ref ast, Global* import);

void addTable(Ref ast, Module* wasm);

void addStart(Ref ast, Module* wasm);

void addExports(Ref ast, Module* wasm);

void addGlobal(Ref ast, Global* global, Module* module);

void addMemoryFuncs(Ref ast, Module* wasm);

void addMemoryGrowFunc(Ref ast, Module* wasm);

Wasm2JSBuilder() = delete;

Wasm2JSBuilder(const Wasm2JSBuilder&) = delete;

Wasm2JSBuilder& operator=(const Wasm2JSBuilder&) = delete;

// Scan the wasm for important things.

for (auto& exp : wasm->exports) {

if (exp->kind == ExternalKind::Function) {

functionsCallableFromOutside.insert(*exp->getInternalName());

}

}

ElementUtils::iterAllElementFunctionNames(

wasm, [&](Name name) { functionsCallableFromOutside.insert(name); });

// Collect passive data segment indices.

for (Index i = 0; i < wasm->dataSegments.size(); ++i) {

dataIndices[wasm->dataSegments[i]->name] = i;

}

// Ensure the scratch memory helpers.

// If later on they aren't needed, we'll clean them up.

ABI::wasm2js::ensureHelpers(wasm);

// Process the code, and optimize if relevant.

// First, do the lowering to a JS-friendly subset.

{

PassRunner runner(wasm, options);

if (flags.emscripten) {

runner.add("llvm-nontrapping-fptoint-lowering");

}

// TODO: only legalize if necessary - emscripten would already do so, and

// likely other toolchains. but spec test suite needs that.

runner.add("legalize-js-interface");

// Before lowering non-JS operations we can optimize some instructions which

// may simplify next passes

if (options.optimizeLevel > 0) {

runner.add("optimize-for-js");

}

// First up remove as many non-JS operations we can, including things like

// 64-bit integer multiplication/division, `f32.nearest` instructions, etc.

// This may inject intrinsics which use i64 so it needs to be run before the

// i64-to-i32 lowering pass.

runner.add("remove-non-js-ops");

// Currently the i64-to-32 lowering pass requires that `flatten` be run

// before it to produce correct code. For some more details about this see

// #1480

runner.add("flatten");

runner.add("i64-to-i32-lowering");

runner.add("alignment-lowering");

// Next, optimize that as best we can. This should not generate

// non-JS-friendly things.

if (options.optimizeLevel > 0) {

// It is especially import to propagate constants after the lowering.

// However, this can be a slow operation, especially after flattening;

// some local simplification helps.

if (options.optimizeLevel >= 3 || options.shrinkLevel >= 1) {

runner.add("simplify-locals-nonesting");

runner.add("precompute-propagate");

// Avoiding reinterpretation is helped by propagation. We also run

// it later down as default optimizations help as well.

runner.add("avoid-reinterprets");

}

runner.addDefaultOptimizationPasses();

runner.add("avoid-reinterprets");

}

// Finally, get the code into the flat form we need for wasm2js itself, and

// optimize that a little in a way that keeps that property.

runner.add("flatten");

// Regardless of optimization level, run some simple optimizations to undo

// some of the effects of flattening.

runner.add("simplify-locals-notee-nostructure");

// Some operations can be very slow if we didn't run full optimizations

// earlier, so don't run them automatically.

if (options.optimizeLevel > 0) {

runner.add("remove-unused-names");

runner.add("merge-blocks");

runner.add("reorder-locals");

runner.add("coalesce-locals");

}

runner.add("reorder-locals");

runner.add("vacuum");

runner.add("remove-unused-module-elements");

// DCE at the end to make sure all IR nodes have valid types for conversion

// to JS, and not unreachable.

runner.add("dce");

runner.setDebug(flags.debug);

runner.run();

}

if (flags.symbolsFile.size() > 0) {

Output out(flags.symbolsFile, wasm::Flags::Text);

Index i = 0;

for (auto& func : wasm->functions) {

out.getStream() << i++ << ':' << func->name.str << '\n';

}

}

#ifndef NDEBUG

if (!WasmValidator().validate(*wasm)) {

std::cout << *wasm << '\n';

Fatal() << "error in validating wasm2js output";

}

#endif

Ref ret = ValueBuilder::makeToplevel();

Ref asmFunc = ValueBuilder::makeFunction(funcName);

ret[1]->push_back(asmFunc);

ValueBuilder::appendArgumentToFunction(asmFunc, importObject);

// add memory import

if (!wasm->memories.empty()) {

if (wasm->memories[0]->imported()) {

ensureModuleVar(asmFunc[3], *wasm->memories[0]);

// find memory and buffer in imports

Ref theVar = ValueBuilder::makeVar();

asmFunc[3]->push_back(theVar);

ValueBuilder::appendToVar(

theVar, "memory", getImportName(*wasm->memories[0]));

// Assign `buffer = memory.buffer`

Ref buf = ValueBuilder::makeVar();

asmFunc[3]->push_back(buf);

ValueBuilder::appendToVar(

buf,

BUFFER,

ValueBuilder::makeDot(ValueBuilder::makeName("memory"),

ValueBuilder::makeName("buffer")));

// If memory is growable, override the imported memory's grow method to

// ensure so that when grow is called from the output it works as expected

if (wasm->memories[0]->max > wasm->memories[0]->initial) {

asmFunc[3]->push_back(

ValueBuilder::makeStatement(ValueBuilder::makeBinary(

ValueBuilder::makeDot(ValueBuilder::makeName("memory"),

ValueBuilder::makeName("grow")),

SET,

ValueBuilder::makeName(WASM_MEMORY_GROW))));

}

} else {

Ref theVar = ValueBuilder::makeVar();

asmFunc[3]->push_back(theVar);

ValueBuilder::appendToVar(theVar,

BUFFER,

ValueBuilder::makeNew(ValueBuilder::makeCall(

ValueBuilder::makeName("ArrayBuffer"),

ValueBuilder::makeInt(Address::address32_t(

wasm->memories[0]->initial.addr

<< wasm->memories[0]->pageSizeLog2)))));

}

}

// add imported tables

ModuleUtils::iterImportedTables(*wasm, [&](Table* table) {

ensureModuleVar(asmFunc[3], *table);

Ref theVar = ValueBuilder::makeVar();

asmFunc[3]->push_back(theVar);

ValueBuilder::appendToVar(theVar, FUNCTION_TABLE, getImportName(*table));

});

// create heaps, etc

addBasics(asmFunc[3], wasm);

ModuleUtils::iterImportedFunctions(

*wasm, [&](Function* import) { addFunctionImport(asmFunc[3], import); });

ModuleUtils::iterImportedGlobals(

*wasm, [&](Global* import) { addGlobalImport(asmFunc[3], import); });

// Note the names of functions. We need to do this here as when generating

// mangled local names we need them not to conflict with these (see fromName)

// so we can't wait until we parse each function to note its name.

for (auto& f : wasm->functions) {

fromName(f->name, NameScope::Top);

}

// globals

bool generateFetchHighBits = false;

ModuleUtils::iterDefinedGlobals(*wasm, [&](Global* global) {

addGlobal(asmFunc[3], global, wasm);

if (flags.allowAsserts && global->name == INT64_TO_32_HIGH_BITS) {

generateFetchHighBits = true;

}

});

if (flags.emscripten) {

asmFunc[3]->push_back(

ValueBuilder::makeName("// EMSCRIPTEN_START_FUNCS\n"));

}

// functions

ModuleUtils::iterDefinedFunctions(*wasm, [&](Function* func) {

asmFunc[3]->push_back(processFunction(wasm, func));

});

if (generateFetchHighBits) {

Builder builder(*wasm);

asmFunc[3]->push_back(

processFunction(wasm,

wasm->addFunction(builder.makeFunction(

WASM_FETCH_HIGH_BITS,

Signature(Type::none, Type::i32),

{},

builder.makeReturn(builder.makeGlobalGet(

INT64_TO_32_HIGH_BITS, Type::i32))))));

wasm->addExport(new Export(

WASM_FETCH_HIGH_BITS, ExternalKind::Function, WASM_FETCH_HIGH_BITS));

}

if (flags.emscripten) {

asmFunc[3]->push_back(ValueBuilder::makeName("// EMSCRIPTEN_END_FUNCS\n"));

}

if (needsBufferView(*wasm)) {

asmFunc[3]->push_back(

ValueBuilder::makeBinary(ValueBuilder::makeName("bufferView"),

SET,

ValueBuilder::makeName(HEAPU8)));

}

if (hasActiveSegments(*wasm)) {

asmFunc[3]->push_back(

ValueBuilder::makeCall(ValueBuilder::makeName("initActiveSegments"),

ValueBuilder::makeName(importObject)));

}

addTable(asmFunc[3], wasm);

addStart(asmFunc[3], wasm);

addExports(asmFunc[3], wasm);

return ret;

if (!wasm->memories.empty()) {

// heaps, var HEAP8 = new global.Int8Array(buffer); etc

auto addHeap = [&](IString name, IString view) {

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

ValueBuilder::appendToVar(theVar,

name,

ValueBuilder::makeNew(ValueBuilder::makeCall(

view, ValueBuilder::makeName(BUFFER))));

};

addHeap(HEAP8, INT8ARRAY);

addHeap(HEAP16, INT16ARRAY);

addHeap(HEAP32, INT32ARRAY);

addHeap(HEAPU8, UINT8ARRAY);

addHeap(HEAPU16, UINT16ARRAY);

addHeap(HEAPU32, UINT32ARRAY);

addHeap(HEAPF32, FLOAT32ARRAY);

addHeap(HEAPF64, FLOAT64ARRAY);

}

// core asm.js imports

auto addMath = [&](IString name, IString base) {

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

ValueBuilder::appendToVar(

theVar, name, ValueBuilder::makeDot(ValueBuilder::makeName(MATH), base));

};

addMath(MATH_IMUL, IMUL);

addMath(MATH_FROUND, FROUND);

addMath(MATH_ABS, ABS);

addMath(MATH_CLZ32, CLZ32);

addMath(MATH_MIN, MIN);

addMath(MATH_MAX, MAX);

addMath(MATH_FLOOR, FLOOR);

addMath(MATH_CEIL, CEIL);

addMath(MATH_TRUNC, TRUNC);

addMath(MATH_SQRT, SQRT);

if (seenModuleImports.count(imp.module) > 0) {

return;

}

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

Ref rhs;

if (needsQuoting(imp.module)) {

rhs = ValueBuilder::makeSub(ValueBuilder::makeName(importObject),

ValueBuilder::makeString(imp.module));

} else {

rhs = ValueBuilder::makeDot(ValueBuilder::makeName(importObject),

ValueBuilder::makeName(imp.module));

}

ValueBuilder::appendToVar(theVar, fromName(imp.module, NameScope::Top), rhs);

seenModuleImports.insert(imp.module);

if (needsQuoting(imp.base)) {

return ValueBuilder::makeSub(

ValueBuilder::makeName(fromName(imp.module, NameScope::Top)),

ValueBuilder::makeString(imp.base));

} else {

return ValueBuilder::makeDot(

ValueBuilder::makeName(fromName(imp.module, NameScope::Top)),

ValueBuilder::makeName(imp.base));

}

// The scratch memory helpers are emitted in the glue, see code and comments

// below.

if (ABI::wasm2js::isHelper(import->base)) {

return;

}

ensureModuleVar(ast, *import);

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

ValueBuilder::appendToVar(

theVar, fromName(import->name, NameScope::Top), getImportName(*import));

ensureModuleVar(ast, *import);

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

Ref value = getImportName(*import);

if (import->type == Type::i32) {

value = makeJsCoercion(value, JS_INT);

}

ValueBuilder::appendToVar(

theVar, fromName(import->name, NameScope::Top), value);

if (wasm->tables.size() == 0) {

return;

}

bool perElementInit = false;

// Emit a simple flat table as a JS array literal. Otherwise,

// emit assignments separately for each index.

Ref theArray = ValueBuilder::makeArray();

for (auto& table : wasm->tables) {

if (!table->type.isFunction()) {

Fatal() << "wasm2js doesn't support non-function tables\n";

}

if (!table->imported()) {

TableUtils::FlatTable flat(*wasm, *table);

if (flat.valid) {

for (auto& name : flat.names) {

if (name.is()) {

name = fromName(name, NameScope::Top);

} else {

name = NULL_;

}

ValueBuilder::appendToArray(theArray, ValueBuilder::makeName(name));

}

} else {

perElementInit = true;

Ref initial =

ValueBuilder::makeInt(Address::address32_t(table->initial.addr));

theArray = ValueBuilder::makeNew(

ValueBuilder::makeCall(IString("Array"), initial));

}

} else {

perElementInit = true;

}

if (isTableExported(*wasm)) {

// If the table is exported use a fake WebAssembly.Table object

// We don't handle the case where a table is both imported and exported.

if (table->imported()) {

Fatal() << "wasm2js doesn't support a table that is both imported and "

"exported\n";

}

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

Ref table = ValueBuilder::makeCall(IString("Table"), theArray);

ValueBuilder::appendToVar(theVar, FUNCTION_TABLE, table);

} else if (!table->imported()) {

// Otherwise if the table is internal (neither imported not exported).

// Just use a plain array in this case, avoiding the Table.

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

ValueBuilder::appendToVar(theVar, FUNCTION_TABLE, theArray);

}

if (perElementInit) {

// TODO: optimize for size

ModuleUtils::iterTableSegments(

*wasm, table->name, [&](ElementSegment* segment) {

auto offset = segment->offset;

ElementUtils::iterElementSegmentFunctionNames(

segment, [&](Name entry, Index i) {

Ref index;

if (auto* c = offset->dynCast<Const>()) {

index = ValueBuilder::makeInt(c->value.geti32() + i);

} else if (auto* get = offset->dynCast<GlobalGet>()) {

index = ValueBuilder::makeBinary(

ValueBuilder::makeName(

stringToIString(asmangle(get->name.toString()))),

PLUS,

ValueBuilder::makeNum(i));

} else {

WASM_UNREACHABLE("unexpected expr type");

}

ast->push_back(

ValueBuilder::makeStatement(ValueBuilder::makeBinary(

ValueBuilder::makeSub(ValueBuilder::makeName(FUNCTION_TABLE),

index),

SET,

ValueBuilder::makeName(fromName(entry, NameScope::Top)))));

});

});

}

}

if (wasm->start.is()) {

ast->push_back(

ValueBuilder::makeCall(fromName(wasm->start, NameScope::Top)));

}

Ref exports = ValueBuilder::makeObject();

for (auto& export_ : wasm->exports) {

switch (export_->kind) {

case ExternalKind::Function: {

ValueBuilder::appendToObjectWithQuotes(

exports,

fromName(export_->name, NameScope::Export),

ValueBuilder::makeName(

fromName(*export_->getInternalName(), NameScope::Top)));

break;

}

case ExternalKind::Memory: {

Ref descs = ValueBuilder::makeObject();

Ref growDesc = ValueBuilder::makeObject();

ValueBuilder::appendToObjectWithQuotes(

descs, IString("grow"), growDesc);

if (wasm->memories[0]->max > wasm->memories[0]->initial) {

ValueBuilder::appendToObjectWithQuotes(

growDesc,

IString("value"),

ValueBuilder::makeName(WASM_MEMORY_GROW));

}

Ref bufferDesc = ValueBuilder::makeObject();

Ref bufferGetter = ValueBuilder::makeFunction(IString(""));

bufferGetter[3]->push_back(

ValueBuilder::makeReturn(ValueBuilder::makeName(BUFFER)));

ValueBuilder::appendToObjectWithQuotes(

bufferDesc, IString("get"), bufferGetter);

ValueBuilder::appendToObjectWithQuotes(

descs, IString("buffer"), bufferDesc);

Ref memory = ValueBuilder::makeCall(

ValueBuilder::makeDot(ValueBuilder::makeName(IString("Object")),

IString("create")),

ValueBuilder::makeDot(ValueBuilder::makeName(IString("Object")),

IString("prototype")));

ValueBuilder::appendToCall(memory, descs);

ValueBuilder::appendToObjectWithQuotes(

exports, fromName(export_->name, NameScope::Export), memory);

break;

}

case ExternalKind::Table: {

ValueBuilder::appendToObjectWithQuotes(

exports,

fromName(export_->name, NameScope::Export),

ValueBuilder::makeName(FUNCTION_TABLE));

break;

}

case ExternalKind::Global: {

Ref object = ValueBuilder::makeObject();

IString identName =

fromName(*export_->getInternalName(), NameScope::Top);

// getter

{

Ref block = ValueBuilder::makeBlock();

block[1]->push_back(

ValueBuilder::makeReturn(ValueBuilder::makeName(identName)));

ValueBuilder::appendToObjectAsGetter(object, IString("value"), block);

}

// setter

{

std::ostringstream buffer;

buffer << '_' << identName;

auto setterParam = stringToIString(buffer.str());

auto block = ValueBuilder::makeBlock();

block[1]->push_back(

ValueBuilder::makeBinary(ValueBuilder::makeName(identName),

SET,

ValueBuilder::makeName(setterParam)));

ValueBuilder::appendToObjectAsSetter(

object, IString("value"), setterParam, block);

}

ValueBuilder::appendToObjectWithQuotes(

exports, fromName(export_->name, NameScope::Export), object);

break;

}

case ExternalKind::Tag:

case ExternalKind::Invalid:

Fatal() << "unsupported export type: " << export_->name << "\n";

}

}

if (!wasm->memories.empty()) {

addMemoryFuncs(ast, wasm);

}

ast->push_back(

ValueBuilder::makeStatement(ValueBuilder::makeReturn(exports)));

Ref theVar = ValueBuilder::makeVar();

ast->push_back(theVar);

Ref init = processExpression(global->init, module);

ValueBuilder::appendToVar(

theVar, fromName(global->name, NameScope::Top), init);

Function* func,

bool standaloneFunction) {

if (standaloneFunction) {

// We are only printing a function, not a whole module. Prepare it for

// translation now (if there were a module, we'd have done this for all

// functions in parallel, earlier).

PassRunner runner(m);

// We only run a subset of all passes here. TODO: create a full valid module

// for each assertion body.

runner.add("flatten");

runner.add("simplify-locals-notee-nostructure");

runner.add("reorder-locals");

runner.add("remove-unused-names");

runner.add("vacuum");

runner.runOnFunction(func);

}

// We process multiple functions from a single Wasm2JSBuilder instance, so

// clean up the function-specific local state before each function.

frees.clear();

temps.clear();

// We will be symbolically referring to all variables in the function, so make

// sure that everything has a name and it's unique.

Names::ensureNames(func);

Ref ret = ValueBuilder::makeFunction(fromName(func->name, NameScope::Top));

// arguments

bool needCoercions = options.optimizeLevel == 0 || standaloneFunction ||

functionsCallableFromOutside.count(func->name);

for (Index i = 0; i < func->getNumParams(); i++) {

IString name = fromName(func->getLocalNameOrGeneric(i), NameScope::Local);

ValueBuilder::appendArgumentToFunction(ret, name);

if (needCoercions) {

auto jsType = wasmToJsType(func->getLocalType(i));

if (needsJsCoercion(jsType)) {

ret[3]->push_back(ValueBuilder::makeStatement(ValueBuilder::makeBinary(

ValueBuilder::makeName(name),

SET,

makeJsCoercion(ValueBuilder::makeName(name), jsType))));

}

}

}

Ref theVar = ValueBuilder::makeVar();

size_t theVarIndex = ret[3]->size();

ret[3]->push_back(theVar);

// body

flattenAppend(ret,

processExpression(func->body, m, func, standaloneFunction));

// vars, including new temp vars

for (Index i = func->getVarIndexBase(); i < func->getNumLocals(); i++) {

ValueBuilder::appendToVar(

theVar,

fromName(func->getLocalNameOrGeneric(i), NameScope::Local),

makeJsCoercedZero(wasmToJsType(func->getLocalType(i))));

}

if (theVar[1]->size() == 0) {

ret[3]->splice(theVarIndex, 1);

}

return ret;

Module* m,

Function* func,

bool standaloneFunction) {

// Switches are tricky to handle - in wasm they often come with

// massively-nested "towers" of blocks, which if naively translated

// to JS may exceed parse recursion limits of VMs. Therefore even when

// not optimizing we work hard to emit minimal and minimally-nested

// switches.

// We do so by pre-scanning for br_tables and noting which of their

// targets can be hoisted up into them, e.g.

//

// (block $a

// (block $b

// (block $c

// (block $d

// (block $e

// (br_table $a $b $c $d $e (..))

// )

// ;; code X (for block $e)

// ;; implicit fallthrough - can be done in the switch too

// )

// ;; code Y

// (br $c) ;; branch which is identical to a fallthrough

// )

// ;; code Z

// (br $a) ;; skip some blocks - can't do this in a switch!

// )

// ;; code W

// )

//

// Every branch we see is a potential hazard - all targets must not

// be optimized into the switch, since they must be reached normally,

// unless they happen to be right after us, in which case it's just

// a fallthrough anyhow.

struct SwitchProcessor : public ExpressionStackWalker<SwitchProcessor> {

// A list of expressions we don't need to emit, as we are handling them

// in another way.

std::set<Expression*> unneededExpressions;

struct SwitchCase {

Name target;

std::vector<Expression*> code;

SwitchCase(Name target) : target(target) {}

};

// The switch cases we found that we can hoist up.

std::map<Switch*, std::vector<SwitchCase>> hoistedSwitchCases;

void visitSwitch(Switch* brTable) {

Index i = expressionStack.size() - 1;

assert(expressionStack[i] == brTable);

// A set of names we must stop at, since we've seen branches to them.

std::set<Name> namesBranchedTo;

while (1) {

// Stop if we are at the top level.

if (i == 0) {

break;

}

i--;

auto* child = expressionStack[i + 1];

auto* curr = expressionStack[i];

// Stop if the current node is not a block with the child in the

// first position, i.e., the classic switch pattern.

auto* block = curr->dynCast<Block>();

if (!block || block->list[0] != child) {

break;

}

// Ignore the case of a name-less block for simplicity (merge-blocks

// would have removed it).

if (!block->name.is()) {

break;

}

// If we have already seen this block, stop here.

if (unneededExpressions.count(block)) {

// XXX FIXME we should probably abort the entire optimization