/*

* Copyright 2015 WebAssembly Community Group participants

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

//

// asm.js-to-WebAssembly translator. Uses the Emscripten optimizer

// infrastructure.

//

#ifndef wasm_asm2wasm_h

#define wasm_asm2wasm_h

#include "wasm.h"

#include "emscripten-optimizer/optimizer.h"

#include "mixed_arena.h"

#include "shared-constants.h"

#include "asmjs/shared-constants.h"

#include "asm_v_wasm.h"

#include "passes/passes.h"

#include "pass.h"

#include "parsing.h"

#include "ir/bits.h"

#include "ir/branch-utils.h"

#include "ir/literal-utils.h"

#include "ir/trapping.h"

#include "ir/utils.h"

#include "wasm-builder.h"

#include "wasm-emscripten.h"

#include "wasm-module-building.h"

namespace wasm {

using namespace cashew;

// Names

Name I32_CTTZ("i32_cttz"),

I32_CTPOP("i32_ctpop"),

I32_BC2F("i32_bc2f"),

I32_BC2I("i32_bc2i"),

I64("i64"),

I64_CONST("i64_const"),

I64_ADD("i64_add"),

I64_SUB("i64_sub"),

I64_MUL("i64_mul"),

I64_UDIV("i64_udiv"),

I64_SDIV("i64_sdiv"),

I64_UREM("i64_urem"),

I64_SREM("i64_srem"),

I64_AND("i64_and"),

I64_OR("i64_or"),

I64_XOR("i64_xor"),

I64_SHL("i64_shl"),

I64_ASHR("i64_ashr"),

I64_LSHR("i64_lshr"),

I64_EQ("i64_eq"),

I64_NE("i64_ne"),

I64_ULE("i64_ule"),

I64_SLE("i64_sle"),

I64_UGE("i64_uge"),

I64_SGE("i64_sge"),

I64_ULT("i64_ult"),

I64_SLT("i64_slt"),

I64_UGT("i64_ugt"),

I64_SGT("i64_sgt"),

I64_TRUNC("i64_trunc"),

I64_SEXT("i64_sext"),

I64_ZEXT("i64_zext"),

I64_S2F("i64_s2f"),

I64_S2D("i64_s2d"),

I64_U2F("i64_u2f"),

I64_U2D("i64_u2d"),

I64_F2S("i64_f2s"),

I64_D2S("i64_d2s"),

I64_F2U("i64_f2u"),

I64_D2U("i64_d2u"),

I64_BC2D("i64_bc2d"),

I64_BC2I("i64_bc2i"),

I64_CTTZ("i64_cttz"),

I64_CTLZ("i64_ctlz"),

I64_CTPOP("i64_ctpop"),

F32_COPYSIGN("f32_copysign"),

F64_COPYSIGN("f64_copysign"),

LOAD1("load1"),

LOAD2("load2"),

LOAD4("load4"),

LOAD8("load8"),

LOADF("loadf"),

LOADD("loadd"),

STORE1("store1"),

STORE2("store2"),

STORE4("store4"),

STORE8("store8"),

STOREF("storef"),

STORED("stored"),

FTCALL("ftCall_"),

MFTCALL("mftCall_"),

MAX_("max"),

MIN_("min"),

ATOMICS("Atomics"),

ATOMICS_LOAD("load"),

ATOMICS_STORE("store"),

ATOMICS_EXCHANGE("exchange"),

ATOMICS_COMPARE_EXCHANGE("compareExchange"),

ATOMICS_ADD("add"),

ATOMICS_SUB("sub"),

ATOMICS_AND("and"),

ATOMICS_OR("or"),

ATOMICS_XOR("xor"),

I64_ATOMICS_LOAD("i64_atomics_load"),

I64_ATOMICS_STORE("i64_atomics_store"),

I64_ATOMICS_AND("i64_atomics_and"),

I64_ATOMICS_OR("i64_atomics_or"),

I64_ATOMICS_XOR("i64_atomics_xor"),

I64_ATOMICS_ADD("i64_atomics_add"),

I64_ATOMICS_SUB("i64_atomics_sub"),

I64_ATOMICS_EXCHANGE("i64_atomics_exchange"),

I64_ATOMICS_COMPAREEXCHANGE("i64_atomics_compareExchange"),

EMSCRIPTEN_DEBUGINFO("emscripten_debuginfo");

// Utilities

static void abort_on(std::string why, Ref element) {

std::cerr << why << ' ';

element->stringify(std::cerr);

std::cerr << '\n';

abort();

}

static void abort_on(std::string why, IString element) {

std::cerr << why << ' ' << element.str << '\n';

abort();

}

Index indexOr(Index x, Index y) {

return x ? x : y;

}

// useful when we need to see our parent, in an asm.js expression stack

struct AstStackHelper {

static std::vector<Ref> astStack;

AstStackHelper(Ref curr) {

astStack.push_back(curr);

}

~AstStackHelper() {

astStack.pop_back();

}

Ref getParent() {

if (astStack.size() >= 2) {

return astStack[astStack.size()-2];

} else {

return Ref();

}

}

};

std::vector<Ref> AstStackHelper::astStack;

static bool startsWith(const char* string, const char *prefix) {

while (1) {

if (*prefix == 0) return true;

if (*string == 0) return false;

if (*string++ != *prefix++) return false;

}

};

//

// Asm2WasmPreProcessor - does some initial parsing/processing

// of asm.js code.

//

struct Asm2WasmPreProcessor {

bool memoryGrowth = false;

bool debugInfo = false;

std::vector<std::string> debugInfoFileNames;

std::unordered_map<std::string, Index> debugInfoFileIndices;

char* allocatedCopy = nullptr;

~Asm2WasmPreProcessor() {

if (allocatedCopy) free(allocatedCopy);

}

char* process(char* input) {

// emcc --separate-asm modules can look like

//

// Module["asm"] = (function(global, env, buffer) {

// ..

// });

//

// we need to clean that up.

if (*input == 'M') {

size_t num = strlen(input);

while (*input != 'f') {

input++;

num--;

}

char *end = input + num - 1;

while (*end != '}') {

*end = 0;

end--;

}

}

// asm.js memory growth uses a quite elaborate pattern. Instead of parsing and

// matching it, we do a simpler detection on emscripten's asm.js output format

const char* START_FUNCS = "// EMSCRIPTEN_START_FUNCS";

char *marker = strstr(input, START_FUNCS);

if (marker) {

*marker = 0; // look for memory growth code just up to here, as an optimization

}

char *growthSign = strstr(input, "return true;"); // this can only show up in growth code, as normal asm.js lacks "true"

if (growthSign) {

memoryGrowth = true;

// clean out this function, we don't need it. first where it starts

char *growthFuncStart = growthSign;

while (*growthFuncStart != '{') growthFuncStart--; // skip body

while (*growthFuncStart != '(') growthFuncStart--; // skip params

while (*growthFuncStart != ' ') growthFuncStart--; // skip function name

while (*growthFuncStart != 'f') growthFuncStart--; // skip 'function'

assert(strstr(growthFuncStart, "function ") == growthFuncStart);

char *growthFuncEnd = strchr(growthSign, '}');

assert(growthFuncEnd > growthFuncStart + 5);

growthFuncStart[0] = '/';

growthFuncStart[1] = '*';

growthFuncEnd--;

growthFuncEnd[0] = '*';

growthFuncEnd[1] = '/';

}

if (marker) {

*marker = START_FUNCS[0];

}

// handle debug info, if this build wants that.

if (debugInfo) {

// asm.js debug info comments look like

// ..command..; //@line 4 "tests/hello_world.c"

// we convert those into emscripten_debuginfo(file, line)

// calls, where the params are indices into a mapping. then

// the compiler and optimizer can operate on them. after

// that, we can apply the debug info to the wasm node right

// before it - this is guaranteed to be correct without opts,

// and is usually decently accurate with them.

const auto SCALE_FACTOR = 1.25; // an upper bound on how much more space we need as a multiple of the original

const auto ADD_FACTOR = 100; // an upper bound on how much we write for each debug info element itself

auto size = strlen(input);

auto upperBound = Index(size * SCALE_FACTOR) + ADD_FACTOR;

char* copy = allocatedCopy = (char*)malloc(upperBound);

char* end = copy + upperBound;

char* out = copy;

std::string DEBUGINFO_INTRINSIC = EMSCRIPTEN_DEBUGINFO.str;

auto DEBUGINFO_INTRINSIC_SIZE = DEBUGINFO_INTRINSIC.size();

const char* UNKNOWN_FILE = "(unknown)";

bool seenUseAsm = false;

while (input[0]) {

if (out + ADD_FACTOR >= end) {

Fatal() << "error in handling debug info";

}

if (startsWith(input, "//@line")) {

char* linePos = input + 8;

char* lineEnd = strpbrk(input + 8, " \n");

if (!lineEnd) {

// comment goes to end of input

break;

}

input = lineEnd + 1;

std::string file;

if (*lineEnd == ' ') {

// we have a file

char* filePos = strpbrk(input, "\"\n");

if (!filePos) {

// goes to end of input

break;

}

if (*filePos == '"') {

char* fileEnd = strpbrk(filePos + 1, "\"\n");

input = fileEnd + 1;

*fileEnd = 0;

file = filePos + 1;

} else {

file = UNKNOWN_FILE;

input = filePos + 1;

}

} else {

// no file, we found \n

file = UNKNOWN_FILE;

}

*lineEnd = 0;

std::string line = linePos;

auto iter = debugInfoFileIndices.find(file);

if (iter == debugInfoFileIndices.end()) {

Index index = debugInfoFileNames.size();

debugInfoFileNames.push_back(file);

debugInfoFileIndices[file] = index;

}

std::string fileIndex = std::to_string(debugInfoFileIndices[file]);

// write out the intrinsic

strcpy(out, DEBUGINFO_INTRINSIC.c_str());

out += DEBUGINFO_INTRINSIC_SIZE;

*out++ = '(';

strcpy(out, fileIndex.c_str());

out += fileIndex.size();

*out++ = ',';

strcpy(out, line.c_str());

out += line.size();

*out++ = ')';

*out++ = ';';

} else if (!seenUseAsm && (startsWith(input, "asm'") || startsWith(input, "asm\""))) {

// end of "use asm" or "almost asm"

const auto SKIP = 5; // skip the end of "use asm"; (5 chars, a,s,m," or ',;)

seenUseAsm = true;

memcpy(out, input, SKIP);

out += SKIP;

input += SKIP;

// add a fake import for the intrinsic, so the module validates

std::string import = "\n var emscripten_debuginfo = env.emscripten_debuginfo;";

strcpy(out, import.c_str());

out += import.size();

} else {

*out++ = *input++;

}

}

if (out >= end) {

Fatal() << "error in handling debug info";

}

*out = 0;

input = copy;

}

return input;

}

};

static CallImport* checkDebugInfo(Expression* curr) {

if (auto* call = curr->dynCast<CallImport>()) {

if (call->target == EMSCRIPTEN_DEBUGINFO) {

return call;

}

}

return nullptr;

}

// Debug info appears in the ast as calls to the debug intrinsic. These are usually

// after the relevant node. We adjust them to a position that is not dce-able, so that

// they are not trivially removed when optimizing.

struct AdjustDebugInfo : public WalkerPass<PostWalker<AdjustDebugInfo, Visitor<AdjustDebugInfo>>> {

bool isFunctionParallel() override { return true; }

Pass* create() override { return new AdjustDebugInfo(); }

AdjustDebugInfo() {

name = "adjust-debug-info";

}

void visitBlock(Block* curr) {

// look for a debug info call that is unreachable

if (curr->list.size() == 0) return;

auto* back = curr->list.back();

for (Index i = 1; i < curr->list.size(); i++) {

if (checkDebugInfo(curr->list[i]) && !checkDebugInfo(curr->list[i - 1])) {

// swap them

std::swap(curr->list[i - 1], curr->list[i]);

}

}

if (curr->list.back() != back) {

// we changed the last element, update the type

curr->finalize();

}

}

};

//

// Asm2WasmBuilder - converts an asm.js module into WebAssembly

//

class Asm2WasmBuilder {

public:

Module& wasm;

MixedArena &allocator;

Builder builder;

std::unique_ptr<OptimizingIncrementalModuleBuilder> optimizingBuilder;

// globals

struct MappedGlobal {

Type type;

bool import; // if true, this is an import - we should read the value, not just set a zero

IString module, base;

MappedGlobal() : type(none), import(false) {}

MappedGlobal(Type type) : type(type), import(false) {}

MappedGlobal(Type type, bool import, IString module, IString base) : type(type), import(import), module(module), base(base) {}

};

// function table

std::map<IString, int> functionTableStarts; // each asm function table gets a range in the one wasm table, starting at a location

Asm2WasmPreProcessor& preprocessor;

bool debug;

TrapMode trapMode;

TrappingFunctionContainer trappingFunctions;

PassOptions passOptions;

bool legalizeJavaScriptFFI;

bool runOptimizationPasses;

bool wasmOnly;

public:

std::map<IString, MappedGlobal> mappedGlobals;

private:

void allocateGlobal(IString name, Type type) {

assert(mappedGlobals.find(name) == mappedGlobals.end());

mappedGlobals.emplace(name, MappedGlobal(type));

wasm.addGlobal(builder.makeGlobal(

name,

type,

LiteralUtils::makeZero(type, wasm),

Builder::Mutable

));

}

struct View {

unsigned bytes;

bool integer, signed_;

AsmType type;

View() : bytes(0) {}

View(unsigned bytes, bool integer, bool signed_, AsmType type) : bytes(bytes), integer(integer), signed_(signed_), type(type) {}

};

std::map<IString, View> views; // name (e.g. HEAP8) => view info

// Imported names of Math.*

IString Math_imul;

IString Math_clz32;

IString Math_fround;

IString Math_abs;

IString Math_floor;

IString Math_ceil;

IString Math_sqrt;

IString Math_max;

IString Math_min;

// Imported names of Atomics.*

IString Atomics_load;

IString Atomics_store;

IString Atomics_exchange;

IString Atomics_compareExchange;

IString Atomics_add;

IString Atomics_sub;

IString Atomics_and;

IString Atomics_or;

IString Atomics_xor;

IString llvm_cttz_i32;

IString tempDoublePtr; // imported name of tempDoublePtr

// possibly-minified names, detected via their exports

IString udivmoddi4;

IString getTempRet0;

// function types. we fill in this information as we see

// uses, in the first pass

std::map<IString, std::unique_ptr<FunctionType>> importedFunctionTypes;

void noteImportedFunctionCall(Ref ast, Type resultType, CallImport* call) {

assert(ast[0] == CALL && ast[1]->isString());

IString importName = ast[1]->getIString();

auto type = make_unique<FunctionType>();

type->name = IString((std::string("type$") + importName.str).c_str(), false); // TODO: make a list of such types

type->result = resultType;

for (auto* operand : call->operands) {

type->params.push_back(operand->type);

}

// if we already saw this signature, verify it's the same (or else handle that)

if (importedFunctionTypes.find(importName) != importedFunctionTypes.end()) {

FunctionType* previous = importedFunctionTypes[importName].get();

if (*type != *previous) {

// merge it in. we'll add on extra 0 parameters for ones not actually used, and upgrade types to

// double where there is a conflict (which is ok since in JS, double can contain everything

// i32 and f32 can).

for (size_t i = 0; i < type->params.size(); i++) {

if (previous->params.size() > i) {

if (previous->params[i] == none) {

previous->params[i] = type->params[i]; // use a more concrete type

} else if (previous->params[i] != type->params[i]) {

previous->params[i] = f64; // overloaded type, make it a double

}

} else {

previous->params.push_back(type->params[i]); // add a new param

}

}

// we accept none and a concrete type, but two concrete types mean we need to use an f64 to contain anything

if (previous->result == none) {

previous->result = type->result; // use a more concrete type

} else if (previous->result != type->result && type->result != none) {

previous->result = f64; // overloaded return type, make it a double

}

}

} else {

importedFunctionTypes[importName].swap(type);

}

}

Type getResultTypeOfCallUsingParent(Ref parent, AsmData* data) {

auto result = none;

if (!!parent) {

// if the parent is a seq, we cannot be the last element in it (we would have a coercion, which would be

// the parent), so we must be (us, somethingElse), and so our return is void

if (parent[0] != SEQ) {

result = detectWasmType(parent, data);

}

}

return result;

}

FunctionType* getFunctionType(Ref parent, ExpressionList& operands, AsmData* data) {

Type result = getResultTypeOfCallUsingParent(parent, data);

return ensureFunctionType(getSig(result, operands), &wasm);

}

public:

Asm2WasmBuilder(Module& wasm, Asm2WasmPreProcessor& preprocessor, bool debug, TrapMode trapMode, PassOptions passOptions, bool legalizeJavaScriptFFI, bool runOptimizationPasses, bool wasmOnly)

: wasm(wasm),

allocator(wasm.allocator),

builder(wasm),

preprocessor(preprocessor),

debug(debug),

trapMode(trapMode),

trappingFunctions(trapMode, wasm, /* immediate = */ true),

passOptions(passOptions),

legalizeJavaScriptFFI(legalizeJavaScriptFFI),

runOptimizationPasses(runOptimizationPasses),

wasmOnly(wasmOnly) {}

void processAsm(Ref ast);

private:

AsmType detectAsmType(Ref ast, AsmData *data) {

if (ast->isString()) {

IString name = ast->getIString();

if (!data->isLocal(name)) {

// must be global

assert(mappedGlobals.find(name) != mappedGlobals.end());

return wasmToAsmType(mappedGlobals[name].type);

}

} else if (ast->isArray(SUB) && ast[1]->isString()) {

// could be a heap access, use view info

auto view = views.find(ast[1]->getIString());

if (view != views.end()) {

return view->second.type;

}

}

return detectType(ast, data, false, Math_fround, wasmOnly);

}

Type detectWasmType(Ref ast, AsmData *data) {

return asmToWasmType(detectAsmType(ast, data));

}

bool isUnsignedCoercion(Ref ast) {

return detectSign(ast, Math_fround) == ASM_UNSIGNED;

}

bool isParentUnsignedCoercion(Ref parent) {

// parent may not exist, or may be a non-relevant node

if (!!parent && parent->isArray() && parent[0] == BINARY && isUnsignedCoercion(parent)) {

return true;

}

return false;

}

BinaryOp parseAsmBinaryOp(IString op, Ref left, Ref right, Expression* leftWasm, Expression* rightWasm) {

Type leftType = leftWasm->type;

bool isInteger = leftType == Type::i32;

if (op == PLUS) return isInteger ? BinaryOp::AddInt32 : (leftType == f32 ? BinaryOp::AddFloat32 : BinaryOp::AddFloat64);

if (op == MINUS) return isInteger ? BinaryOp::SubInt32 : (leftType == f32 ? BinaryOp::SubFloat32 : BinaryOp::SubFloat64);

if (op == MUL) return isInteger ? BinaryOp::MulInt32 : (leftType == f32 ? BinaryOp::MulFloat32 : BinaryOp::MulFloat64);

if (op == AND) return BinaryOp::AndInt32;

if (op == OR) return BinaryOp::OrInt32;

if (op == XOR) return BinaryOp::XorInt32;

if (op == LSHIFT) return BinaryOp::ShlInt32;

if (op == RSHIFT) return BinaryOp::ShrSInt32;

if (op == TRSHIFT) return BinaryOp::ShrUInt32;

if (op == EQ) return isInteger ? BinaryOp::EqInt32 : (leftType == f32 ? BinaryOp::EqFloat32 : BinaryOp::EqFloat64);

if (op == NE) return isInteger ? BinaryOp::NeInt32 : (leftType == f32 ? BinaryOp::NeFloat32 : BinaryOp::NeFloat64);

bool isUnsigned = isUnsignedCoercion(left) || isUnsignedCoercion(right);

if (op == DIV) {

if (isInteger) {

return isUnsigned ? BinaryOp::DivUInt32 : BinaryOp::DivSInt32;

}

return leftType == f32 ? BinaryOp::DivFloat32 : BinaryOp::DivFloat64;

}

if (op == MOD) {

if (isInteger) {

return isUnsigned ? BinaryOp::RemUInt32 : BinaryOp::RemSInt32;

}

return BinaryOp::RemSInt32; // XXX no floating-point remainder op, this must be handled by the caller

}

if (op == GE) {

if (isInteger) {

return isUnsigned ? BinaryOp::GeUInt32 : BinaryOp::GeSInt32;

}

return leftType == f32 ? BinaryOp::GeFloat32 : BinaryOp::GeFloat64;

}

if (op == GT) {

if (isInteger) {

return isUnsigned ? BinaryOp::GtUInt32 : BinaryOp::GtSInt32;

}

return leftType == f32 ? BinaryOp::GtFloat32 : BinaryOp::GtFloat64;

}

if (op == LE) {

if (isInteger) {

return isUnsigned ? BinaryOp::LeUInt32 : BinaryOp::LeSInt32;

}

return leftType == f32 ? BinaryOp::LeFloat32 : BinaryOp::LeFloat64;

}

if (op == LT) {

if (isInteger) {

return isUnsigned ? BinaryOp::LtUInt32 : BinaryOp::LtSInt32;

}

return leftType == f32 ? BinaryOp::LtFloat32 : BinaryOp::LtFloat64;

}

abort_on("bad wasm binary op", op);

abort(); // avoid warning

}

int32_t bytesToShift(unsigned bytes) {

switch (bytes) {

case 1: return 0;

case 2: return 1;

case 4: return 2;

case 8: return 3;

default: {}

}

abort();

return -1; // avoid warning

}

std::map<unsigned, Ref> tempNums;

Literal checkLiteral(Ref ast, bool rawIsInteger = true) {

if (ast->isNumber()) {

if (rawIsInteger) {

return Literal((int32_t)ast->getInteger());

} else {

return Literal(ast->getNumber());

}

} else if (ast->isArray(UNARY_PREFIX)) {

if (ast[1] == PLUS && ast[2]->isNumber()) {

return Literal((double)ast[2]->getNumber());

}

if (ast[1] == MINUS && ast[2]->isNumber()) {

double num = -ast[2]->getNumber();

if (isSInteger32(num)) return Literal((int32_t)num);

if (isUInteger32(num)) return Literal((uint32_t)num);

assert(false && "expected signed or unsigned int32");

}

if (ast[1] == PLUS && ast[2]->isArray(UNARY_PREFIX) && ast[2][1] == MINUS && ast[2][2]->isNumber()) {

return Literal((double)-ast[2][2]->getNumber());

}

if (ast[1] == MINUS && ast[2]->isArray(UNARY_PREFIX) && ast[2][1] == PLUS && ast[2][2]->isNumber()) {

return Literal((double)-ast[2][2]->getNumber());

}

} else if (wasmOnly && ast->isArray(CALL) && ast[1]->isString() && ast[1] == I64_CONST) {

uint64_t low = ast[2][0]->getNumber();

uint64_t high = ast[2][1]->getNumber();

return Literal(uint64_t(low + (high << 32)));

}

return Literal();

}

Literal getLiteral(Ref ast) {

Literal ret = checkLiteral(ast);

assert(ret.type != none);

return ret;

}

void fixCallType(Expression* call, Type type) {

if (call->is<Call>()) call->cast<Call>()->type = type;

if (call->is<CallImport>()) call->cast<CallImport>()->type = type;

else if (call->is<CallIndirect>()) call->cast<CallIndirect>()->type = type;

}

FunctionType* getBuiltinFunctionType(Name module, Name base, ExpressionList* operands = nullptr) {

if (module == GLOBAL_MATH) {

if (base == ABS) {

assert(operands && operands->size() == 1);

Type type = (*operands)[0]->type;

if (type == i32) return ensureFunctionType("ii", &wasm);

if (type == f32) return ensureFunctionType("ff", &wasm);

if (type == f64) return ensureFunctionType("dd", &wasm);

}

}

return nullptr;

}

// ensure a nameless block

Block* blockify(Expression* expression) {

if (expression->is<Block>() && !expression->cast<Block>()->name.is()) return expression->dynCast<Block>();

auto ret = allocator.alloc<Block>();

ret->list.push_back(expression);

ret->finalize();

return ret;

}

Expression* ensureDouble(Expression* expr) {

return wasm::ensureDouble(expr, allocator);

}

Expression* truncateToInt32(Expression* value) {

if (value->type == i64) return builder.makeUnary(UnaryOp::WrapInt64, value);

// either i32, or a call_import whose type we don't know yet (but would be legalized to i32 anyhow)

return value;

}

Function* processFunction(Ref ast);

};

void Asm2WasmBuilder::processAsm(Ref ast) {

assert(ast[0] == TOPLEVEL);

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

Fatal() << "empty input";

}

Ref asmFunction = ast[1][0];

assert(asmFunction[0] == DEFUN);

Ref body = asmFunction[3];

assert(body[0][0] == STRING && (body[0][1]->getIString() == IString("use asm") || body[0][1]->getIString() == IString("almost asm")));

// extra functions that we add, that are not from the compiled code. we need

// to make sure to optimize them normally (OptimizingIncrementalModuleBuilder

// does that on the fly for compiled code)

std::vector<Function*> extraSupportFunctions;

// first, add the memory elements. we do this before the main compile+optimize

// since the optimizer should see the memory

// apply memory growth, if relevant

if (preprocessor.memoryGrowth) {

EmscriptenGlueGenerator generator(wasm);

auto* func = generator.generateMemoryGrowthFunction();

extraSupportFunctions.push_back(func);

wasm.memory.max = Memory::kMaxSize;

}

// import memory

auto memoryImport = make_unique<Import>();

memoryImport->name = MEMORY;

memoryImport->module = ENV;

memoryImport->base = MEMORY;

memoryImport->kind = ExternalKind::Memory;

wasm.memory.exists = true;

wasm.memory.imported = true;

wasm.addImport(memoryImport.release());

// import table

auto tableImport = make_unique<Import>();

tableImport->name = TABLE;

tableImport->module = ENV;

tableImport->base = TABLE;

tableImport->kind = ExternalKind::Table;

wasm.addImport(tableImport.release());

wasm.table.exists = true;

wasm.table.imported = true;

// Import memory offset, if not already there

{

auto* import = new Import;

import->name = Name("memoryBase");

import->module = Name("env");

import->base = Name("memoryBase");

import->kind = ExternalKind::Global;

import->globalType = i32;

wasm.addImport(import);

}

// Import table offset, if not already there

{

auto* import = new Import;

import->name = Name("tableBase");

import->module = Name("env");

import->base = Name("tableBase");

import->kind = ExternalKind::Global;

import->globalType = i32;

wasm.addImport(import);

}

auto addImport = [&](IString name, Ref imported, Type type) {

assert(imported[0] == DOT);

Ref module = imported[1];

IString moduleName;

if (module->isArray(DOT)) {

// we can have (global.Math).floor; skip the 'Math'

assert(module[1]->isString());

if (module[2] == MATH) {

if (imported[2] == IMUL) {

assert(Math_imul.isNull());

Math_imul = name;

return;

} else if (imported[2] == CLZ32) {

assert(Math_clz32.isNull());

Math_clz32 = name;

return;

} else if (imported[2] == FROUND) {

assert(Math_fround.isNull());

Math_fround = name;

return;

} else if (imported[2] == ABS) {

assert(Math_abs.isNull());

Math_abs = name;

return;

} else if (imported[2] == FLOOR) {

assert(Math_floor.isNull());

Math_floor = name;

return;

} else if (imported[2] == CEIL) {

assert(Math_ceil.isNull());

Math_ceil = name;

return;

} else if (imported[2] == SQRT) {

assert(Math_sqrt.isNull());

Math_sqrt = name;

return;

} else if (imported[2] == MAX_) {

assert(Math_max.isNull());

Math_max = name;

return;

} else if (imported[2] == MIN_) {

assert(Math_min.isNull());

Math_min = name;

return;

}

} else if (module[2] == ATOMICS) {

if (imported[2] == ATOMICS_LOAD) {

assert(Atomics_load.isNull());

Atomics_load = name;

return;

} else if (imported[2] == ATOMICS_STORE) {

assert(Atomics_store.isNull());

Atomics_store = name;

return;

} else if (imported[2] == ATOMICS_EXCHANGE) {

assert(Atomics_exchange.isNull());

Atomics_exchange = name;

return;

} else if (imported[2] == ATOMICS_COMPARE_EXCHANGE) {

assert(Atomics_compareExchange.isNull());

Atomics_compareExchange = name;

return;

} else if (imported[2] == ATOMICS_ADD) {

assert(Atomics_add.isNull());

Atomics_add = name;

return;

} else if (imported[2] == ATOMICS_SUB) {

assert(Atomics_sub.isNull());

Atomics_sub = name;

return;

} else if (imported[2] == ATOMICS_AND) {

assert(Atomics_and.isNull());

Atomics_and = name;

return;

} else if (imported[2] == ATOMICS_OR) {

assert(Atomics_or.isNull());

Atomics_or = name;

return;

} else if (imported[2] == ATOMICS_XOR) {

assert(Atomics_xor.isNull());

Atomics_xor = name;

return;

}

}

std::string fullName = module[1]->getCString();

fullName += '.';

fullName += + module[2]->getCString();

moduleName = IString(fullName.c_str(), false);

} else {

assert(module->isString());

moduleName = module->getIString();

if (moduleName == ENV) {

auto base = imported[2]->getIString();

if (base == TEMP_DOUBLE_PTR) {

assert(tempDoublePtr.isNull());

tempDoublePtr = name;

// we don't return here, as we can only optimize out some uses of tDP. So it remains imported

} else if (base == LLVM_CTTZ_I32) {

assert(llvm_cttz_i32.isNull());

llvm_cttz_i32 = name;

return;

}

}

}

auto import = make_unique<Import>();

import->name = name;

import->module = moduleName;

import->base = imported[2]->getIString();

// special-case some asm builtins

if (import->module == GLOBAL && (import->base == NAN_ || import->base == INFINITY_)) {

type = Type::f64;

}

if (type != Type::none) {

// this is a global

import->kind = ExternalKind::Global;

import->globalType = type;

mappedGlobals.emplace(name, type);

// tableBase and memoryBase are used as segment/element offsets, and must be constant;

// otherwise, an asm.js import of a constant is mutable, e.g. STACKTOP

if (name != "tableBase" && name != "memoryBase") {

// we need imported globals to be mutable, but wasm doesn't support that yet, so we must

// import an immutable and create a mutable global initialized to its value

import->name = Name(std::string(import->name.str) + "$asm2wasm$import");

{

wasm.addGlobal(builder.makeGlobal(

name,

type,

builder.makeGetGlobal(import->name, type),

Builder::Mutable

));

}

}

} else {

import->kind = ExternalKind::Function;

}

// we may have already created an import for this manually

if ((name == "tableBase" || name == "memoryBase") &&

(wasm.getImportOrNull(import->base) || wasm.getGlobalOrNull(import->base))) {

return;

}

wasm.addImport(import.release());

};

IString Int8Array, Int16Array, Int32Array, UInt8Array, UInt16Array, UInt32Array, Float32Array, Float64Array;

// set up optimization

if (runOptimizationPasses) {

Index numFunctions = 0;

for (unsigned i = 1; i < body->size(); i++) {

if (body[i][0] == DEFUN) numFunctions++;

}

optimizingBuilder = make_unique<OptimizingIncrementalModuleBuilder>(&wasm, numFunctions, passOptions, [&](PassRunner& passRunner) {

// addPrePasses

if (debug) {

passRunner.setDebug(true);

passRunner.setValidateGlobally(false);

}

// run autodrop first, before optimizations

passRunner.add<AutoDrop>();

if (preprocessor.debugInfo) {

// fix up debug info to better survive optimization

passRunner.add<AdjustDebugInfo>();

}

// optimize relooper label variable usage at the wasm level, where it is easy

passRunner.add("relooper-jump-threading");

}, debug, false /* do not validate globally yet */);

}

// if we see no function tables in the processing below, then the table still exists and has size 0

wasm.table.initial = wasm.table.max = 0;

// first pass - do all global things, aside from function bodies (second pass)

// and function imports and indirect calls (last pass)

for (unsigned i = 1; i < body->size(); i++) {

Ref curr = body[i];

if (curr[0] == VAR) {

// import, global, or table

for (unsigned j = 0; j < curr[1]->size(); j++) {

Ref pair = curr[1][j];

IString name = pair[0]->getIString();

Ref value = pair[1];

if (value->isNumber()) {

// global int

assert(value->getNumber() == 0);

allocateGlobal(name, Type::i32);

} else if (value[0] == BINARY) {

// int import

assert(value[1] == OR && value[3]->isNumber() && value[3]->getNumber() == 0);

Ref import = value[2]; // env.what

addImport(name, import, Type::i32);

} else if (value[0] == UNARY_PREFIX) {

// double import or global