/*

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

*/

#include <algorithm>

#include <fstream>

#include "support/bits.h"

#include "wasm-binary.h"

#include "wasm-stack.h"

#include "ir/module-utils.h"

namespace wasm {

void WasmBinaryWriter::prepare() {

// we need function types for all our functions

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

if (func->type.isNull()) {

func->type = ensureFunctionType(getSig(func.get()), wasm)->name;

}

// TODO: depending on upstream flux https://github.com/WebAssembly/spec/pull/301 might want this: assert(!func->type.isNull());

}

ModuleUtils::BinaryIndexes indexes(*wasm);

mappedFunctions = std::move(indexes.functionIndexes);

mappedGlobals = std::move(indexes.globalIndexes);

importInfo = wasm::make_unique<ImportInfo>(*wasm);

}

void WasmBinaryWriter::write() {

writeHeader();

writeEarlyUserSections();

initializeDebugInfo();

if (sourceMap) {

writeSourceMapProlog();

}

writeTypes();

writeImports();

writeFunctionSignatures();

writeFunctionTableDeclaration();

writeMemory();

writeGlobals();

writeExports();

writeStart();

writeTableElements();

writeFunctions();

writeDataSegments();

if (debugInfo) writeNames();

if (sourceMap && !sourceMapUrl.empty()) writeSourceMapUrl();

if (symbolMap.size() > 0) writeSymbolMap();

if (sourceMap) {

writeSourceMapEpilog();

}

writeLateUserSections();

finishUp();

}

void WasmBinaryWriter::writeHeader() {

if (debug) std::cerr << "== writeHeader" << std::endl;

o << int32_t(BinaryConsts::Magic); // magic number \0asm

o << int32_t(BinaryConsts::Version);

}

int32_t WasmBinaryWriter::writeU32LEBPlaceholder() {

int32_t ret = o.size();

o << int32_t(0);

o << int8_t(0);

return ret;

}

void WasmBinaryWriter::writeResizableLimits(Address initial, Address maximum,

bool hasMaximum, bool shared) {

uint32_t flags =

(hasMaximum ? (uint32_t) BinaryConsts::HasMaximum : 0U) |

(shared ? (uint32_t) BinaryConsts::IsShared : 0U);

o << U32LEB(flags);

o << U32LEB(initial);

if (hasMaximum) {

o << U32LEB(maximum);

}

}

template<typename T>

int32_t WasmBinaryWriter::startSection(T code) {

o << U32LEB(code);

if (sourceMap) sourceMapLocationsSizeAtSectionStart = sourceMapLocations.size();

return writeU32LEBPlaceholder(); // section size to be filled in later

}

void WasmBinaryWriter::finishSection(int32_t start) {

int32_t size = o.size() - start - MaxLEB32Bytes; // section size does not include the reserved bytes of the size field itself

auto sizeFieldSize = o.writeAt(start, U32LEB(size));

if (sizeFieldSize != MaxLEB32Bytes) {

// we can save some room, nice

assert(sizeFieldSize < MaxLEB32Bytes);

std::move(&o[start] + MaxLEB32Bytes, &o[start] + MaxLEB32Bytes + size, &o[start] + sizeFieldSize);

auto adjustment = MaxLEB32Bytes - sizeFieldSize;

o.resize(o.size() - adjustment);

if (sourceMap) {

for (auto i = sourceMapLocationsSizeAtSectionStart; i < sourceMapLocations.size(); ++i) {

sourceMapLocations[i].first -= adjustment;

}

}

}

}

int32_t WasmBinaryWriter::startSubsection(BinaryConsts::UserSections::Subsection code) {

return startSection(code);

}

void WasmBinaryWriter::finishSubsection(int32_t start) {

finishSection(start);

}

void WasmBinaryWriter::writeStart() {

if (!wasm->start.is()) return;

if (debug) std::cerr << "== writeStart" << std::endl;

auto start = startSection(BinaryConsts::Section::Start);

o << U32LEB(getFunctionIndex(wasm->start.str));

finishSection(start);

}

void WasmBinaryWriter::writeMemory() {

if (!wasm->memory.exists || wasm->memory.imported()) return;

if (debug) std::cerr << "== writeMemory" << std::endl;

auto start = startSection(BinaryConsts::Section::Memory);

o << U32LEB(1); // Define 1 memory

writeResizableLimits(wasm->memory.initial, wasm->memory.max,

wasm->memory.hasMax(), wasm->memory.shared);

finishSection(start);

}

void WasmBinaryWriter::writeTypes() {

if (wasm->functionTypes.size() == 0) return;

if (debug) std::cerr << "== writeTypes" << std::endl;

auto start = startSection(BinaryConsts::Section::Type);

o << U32LEB(wasm->functionTypes.size());

for (auto& type : wasm->functionTypes) {

if (debug) std::cerr << "write one" << std::endl;

o << S32LEB(BinaryConsts::EncodedType::Func);

o << U32LEB(type->params.size());

for (auto param : type->params) {

o << binaryType(param);

}

if (type->result == none) {

o << U32LEB(0);

} else {

o << U32LEB(1);

o << binaryType(type->result);

}

}

finishSection(start);

}

int32_t WasmBinaryWriter::getFunctionTypeIndex(Name type) {

// TODO: optimize

for (size_t i = 0; i < wasm->functionTypes.size(); i++) {

if (wasm->functionTypes[i]->name == type) return i;

}

abort();

}

void WasmBinaryWriter::writeImports() {

auto num = importInfo->getNumImports();

if (num == 0) return;

if (debug) std::cerr << "== writeImports" << std::endl;

auto start = startSection(BinaryConsts::Section::Import);

o << U32LEB(num);

auto writeImportHeader = [&](Importable* import) {

writeInlineString(import->module.str);

writeInlineString(import->base.str);

};

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

if (debug) std::cerr << "write one function" << std::endl;

writeImportHeader(func);

o << U32LEB(int32_t(ExternalKind::Function));

o << U32LEB(getFunctionTypeIndex(func->type));

});

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

if (debug) std::cerr << "write one global" << std::endl;

writeImportHeader(global);

o << U32LEB(int32_t(ExternalKind::Global));

o << binaryType(global->type);

o << U32LEB(global->mutable_);

});

if (wasm->memory.imported()) {

if (debug) std::cerr << "write one memory" << std::endl;

writeImportHeader(&wasm->memory);

o << U32LEB(int32_t(ExternalKind::Memory));

writeResizableLimits(wasm->memory.initial, wasm->memory.max,

wasm->memory.hasMax(), wasm->memory.shared);

}

if (wasm->table.imported()) {

if (debug) std::cerr << "write one table" << std::endl;

writeImportHeader(&wasm->table);

o << U32LEB(int32_t(ExternalKind::Table));

o << S32LEB(BinaryConsts::EncodedType::AnyFunc);

writeResizableLimits(wasm->table.initial, wasm->table.max, wasm->table.hasMax(), /*shared=*/false);

}

finishSection(start);

}

void WasmBinaryWriter::writeFunctionSignatures() {

if (importInfo->getNumDefinedFunctions() == 0) return;

if (debug) std::cerr << "== writeFunctionSignatures" << std::endl;

auto start = startSection(BinaryConsts::Section::Function);

o << U32LEB(importInfo->getNumDefinedFunctions());

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

if (debug) std::cerr << "write one" << std::endl;

o << U32LEB(getFunctionTypeIndex(func->type));

});

finishSection(start);

}

void WasmBinaryWriter::writeExpression(Expression* curr) {

ExpressionStackWriter<WasmBinaryWriter>(curr, *this, o, debug);

}

void WasmBinaryWriter::writeFunctions() {

if (importInfo->getNumDefinedFunctions() == 0) return;

if (debug) std::cerr << "== writeFunctions" << std::endl;

auto start = startSection(BinaryConsts::Section::Code);

o << U32LEB(importInfo->getNumDefinedFunctions());

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

size_t sourceMapLocationsSizeAtFunctionStart = sourceMapLocations.size();

if (debug) std::cerr << "write one at" << o.size() << std::endl;

size_t sizePos = writeU32LEBPlaceholder();

size_t start = o.size();

if (debug) std::cerr << "writing" << func->name << std::endl;

// Emit Stack IR if present, and if we can

if (func->stackIR && !sourceMap) {

if (debug) std::cerr << "write Stack IR" << std::endl;

StackIRFunctionStackWriter<WasmBinaryWriter>(func, *this, o, debug);

} else {

if (debug) std::cerr << "write Binaryen IR" << std::endl;

FunctionStackWriter<WasmBinaryWriter>(func, *this, o, sourceMap, debug);

}

size_t size = o.size() - start;

assert(size <= std::numeric_limits<uint32_t>::max());

if (debug) std::cerr << "body size: " << size << ", writing at " << sizePos << ", next starts at " << o.size() << std::endl;

auto sizeFieldSize = o.writeAt(sizePos, U32LEB(size));

if (sizeFieldSize != MaxLEB32Bytes) {

// we can save some room, nice

assert(sizeFieldSize < MaxLEB32Bytes);

std::move(&o[start], &o[start] + size, &o[sizePos] + sizeFieldSize);

auto adjustment = MaxLEB32Bytes - sizeFieldSize;

o.resize(o.size() - adjustment);

if (sourceMap) {

for (auto i = sourceMapLocationsSizeAtFunctionStart; i < sourceMapLocations.size(); ++i) {

sourceMapLocations[i].first -= adjustment;

}

}

}

tableOfContents.functionBodies.emplace_back(func->name, sizePos + sizeFieldSize, size);

});

finishSection(start);

}

void WasmBinaryWriter::writeGlobals() {

if (importInfo->getNumDefinedGlobals() == 0) return;

if (debug) std::cerr << "== writeglobals" << std::endl;

auto start = startSection(BinaryConsts::Section::Global);

auto num = importInfo->getNumDefinedGlobals();

o << U32LEB(num);

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

if (debug) std::cerr << "write one" << std::endl;

o << binaryType(global->type);

o << U32LEB(global->mutable_);

writeExpression(global->init);

o << int8_t(BinaryConsts::End);

});

finishSection(start);

}

void WasmBinaryWriter::writeExports() {

if (wasm->exports.size() == 0) return;

if (debug) std::cerr << "== writeexports" << std::endl;

auto start = startSection(BinaryConsts::Section::Export);

o << U32LEB(wasm->exports.size());

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

if (debug) std::cerr << "write one" << std::endl;

writeInlineString(curr->name.str);

o << U32LEB(int32_t(curr->kind));

switch (curr->kind) {

case ExternalKind::Function: o << U32LEB(getFunctionIndex(curr->value)); break;

case ExternalKind::Table: o << U32LEB(0); break;

case ExternalKind::Memory: o << U32LEB(0); break;

case ExternalKind::Global: o << U32LEB(getGlobalIndex(curr->value)); break;

default: WASM_UNREACHABLE();

}

}

finishSection(start);

}

static bool isEmpty(Memory::Segment& segment) {

return segment.data.size() == 0;

}

static bool isConstantOffset(Memory::Segment& segment) {

return segment.offset->is<Const>();

}

void WasmBinaryWriter::writeDataSegments() {

if (wasm->memory.segments.size() == 0) return;

Index numConstant = 0,

numDynamic = 0;

for (auto& segment : wasm->memory.segments) {

if (!isEmpty(segment)) {

if (isConstantOffset(segment)) {

numConstant++;

} else {

numDynamic++;

}

}

}

// check if we have too many dynamic data segments, which we can do nothing about

auto num = numConstant + numDynamic;

if (numDynamic + 1 >= WebLimitations::MaxDataSegments) {

std::cerr << "too many non-constant-offset data segments, wasm VMs may not accept this binary" << std::endl;

}

// we'll merge constant segments if we must

if (numConstant + numDynamic >= WebLimitations::MaxDataSegments) {

numConstant = WebLimitations::MaxDataSegments - numDynamic - 1;

num = numConstant + numDynamic;

assert(num == WebLimitations::MaxDataSegments - 1);

}

auto start = startSection(BinaryConsts::Section::Data);

o << U32LEB(num);

// first, emit all non-constant-offset segments; then emit the constants,

// which we may merge if forced to

Index emitted = 0;

auto emit = [&](Memory::Segment& segment) {

o << U32LEB(0); // Linear memory 0 in the MVP

writeExpression(segment.offset);

o << int8_t(BinaryConsts::End);

writeInlineBuffer(&segment.data[0], segment.data.size());

emitted++;

};

auto& segments = wasm->memory.segments;

for (auto& segment : segments) {

if (isEmpty(segment)) continue;

if (isConstantOffset(segment)) continue;

emit(segment);

}

// from here on, we concern ourselves with non-empty constant-offset

// segments, the ones which we may need to merge

auto isRelevant = [](Memory::Segment& segment) {

return !isEmpty(segment) && isConstantOffset(segment);

};

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

auto& segment = segments[i];

if (!isRelevant(segment)) continue;

if (emitted + 2 < WebLimitations::MaxDataSegments) {

emit(segment);

} else {

// we can emit only one more segment! merge everything into one

// start the combined segment at the bottom of them all

auto start = segment.offset->cast<Const>()->value.getInteger();

for (Index j = i + 1; j < segments.size(); j++) {

auto& segment = segments[j];

if (!isRelevant(segment)) continue;

auto offset = segment.offset->cast<Const>()->value.getInteger();

start = std::min(start, offset);

}

// create the segment and add in all the data

Const c;

c.value = Literal(int32_t(start));

c.type = i32;

Memory::Segment combined(&c);

for (Index j = i; j < segments.size(); j++) {

auto& segment = segments[j];

if (!isRelevant(segment)) continue;

auto offset = segment.offset->cast<Const>()->value.getInteger();

auto needed = offset + segment.data.size() - start;

if (combined.data.size() < needed) {

combined.data.resize(needed);

}

std::copy(segment.data.begin(), segment.data.end(), combined.data.begin() + offset - start);

}

emit(combined);

break;

}

}

finishSection(start);

}

uint32_t WasmBinaryWriter::getFunctionIndex(Name name) {

assert(mappedFunctions.count(name));

return mappedFunctions[name];

}

uint32_t WasmBinaryWriter::getGlobalIndex(Name name) {

assert(mappedGlobals.count(name));

return mappedGlobals[name];

}

void WasmBinaryWriter::writeFunctionTableDeclaration() {

if (!wasm->table.exists || wasm->table.imported()) return;

if (debug) std::cerr << "== writeFunctionTableDeclaration" << std::endl;

auto start = startSection(BinaryConsts::Section::Table);

o << U32LEB(1); // Declare 1 table.

o << S32LEB(BinaryConsts::EncodedType::AnyFunc);

writeResizableLimits(wasm->table.initial, wasm->table.max, wasm->table.hasMax(), /*shared=*/false);

finishSection(start);

}

void WasmBinaryWriter::writeTableElements() {

if (!wasm->table.exists) return;

if (debug) std::cerr << "== writeTableElements" << std::endl;

auto start = startSection(BinaryConsts::Section::Element);

o << U32LEB(wasm->table.segments.size());

for (auto& segment : wasm->table.segments) {

o << U32LEB(0); // Table index; 0 in the MVP (and binaryen IR only has 1 table)

writeExpression(segment.offset);

o << int8_t(BinaryConsts::End);

o << U32LEB(segment.data.size());

for (auto name : segment.data) {

o << U32LEB(getFunctionIndex(name));

}

}

finishSection(start);

}

void WasmBinaryWriter::writeNames() {

bool hasContents = false;

if (wasm->functions.size() > 0) {

hasContents = true;

getFunctionIndex(wasm->functions[0]->name); // generate mappedFunctions

}

if (!hasContents) return;

if (debug) std::cerr << "== writeNames" << std::endl;

auto start = startSection(BinaryConsts::Section::User);

writeInlineString(BinaryConsts::UserSections::Name);

auto substart = startSubsection(BinaryConsts::UserSections::Subsection::NameFunction);

o << U32LEB(mappedFunctions.size());

Index emitted = 0;

auto add = [&](Function* curr) {

o << U32LEB(emitted);

writeEscapedName(curr->name.str);

emitted++;

};

ModuleUtils::iterImportedFunctions(*wasm, add);

ModuleUtils::iterDefinedFunctions(*wasm, add);

assert(emitted == mappedFunctions.size());

finishSubsection(substart);

/* TODO: locals */

finishSection(start);

}

void WasmBinaryWriter::writeSourceMapUrl() {

if (debug) std::cerr << "== writeSourceMapUrl" << std::endl;

auto start = startSection(BinaryConsts::Section::User);

writeInlineString(BinaryConsts::UserSections::SourceMapUrl);

writeInlineString(sourceMapUrl.c_str());

finishSection(start);

}

void WasmBinaryWriter::writeSymbolMap() {

std::ofstream file(symbolMap);

auto write = [&](Function* func) {

file << getFunctionIndex(func->name) << ":" << func->name.str << std::endl;

};

ModuleUtils::iterImportedFunctions(*wasm, write);

ModuleUtils::iterDefinedFunctions(*wasm, write);

file.close();

}

void WasmBinaryWriter::initializeDebugInfo() {

lastDebugLocation = { 0, /* lineNumber = */ 1, 0 };

}

void WasmBinaryWriter::writeSourceMapProlog() {

*sourceMap << "{\"version\":3,\"sources\":[";

for (size_t i = 0; i < wasm->debugInfoFileNames.size(); i++) {

if (i > 0) *sourceMap << ",";

// TODO respect JSON string encoding, e.g. quotes and control chars.

*sourceMap << "\"" << wasm->debugInfoFileNames[i] << "\"";

}

*sourceMap << "],\"names\":[],\"mappings\":\"";

}

static void writeBase64VLQ(std::ostream& out, int32_t n) {

uint32_t value = n >= 0 ? n << 1 : ((-n) << 1) | 1;

while (1) {

uint32_t digit = value & 0x1F;

value >>= 5;

if (!value) {

// last VLQ digit -- base64 codes 'A'..'Z', 'a'..'f'

out << char(digit < 26 ? 'A' + digit : 'a' + digit - 26);

break;

}

// more VLG digit will follow -- add continuation bit (0x20),

// base64 codes 'g'..'z', '0'..'9', '+', '/'

out << char(digit < 20 ? 'g' + digit : digit < 30 ? '0' + digit - 20 : digit == 30 ? '+' : '/');

}

}

void WasmBinaryWriter::writeSourceMapEpilog() {

// write source map entries

size_t lastOffset = 0;

Function::DebugLocation lastLoc = { 0, /* lineNumber = */ 1, 0 };

for (const auto &offsetAndlocPair : sourceMapLocations) {

if (lastOffset > 0) {

*sourceMap << ",";

}

size_t offset = offsetAndlocPair.first;

const Function::DebugLocation& loc = *offsetAndlocPair.second;

writeBase64VLQ(*sourceMap, int32_t(offset - lastOffset));

writeBase64VLQ(*sourceMap, int32_t(loc.fileIndex - lastLoc.fileIndex));

writeBase64VLQ(*sourceMap, int32_t(loc.lineNumber - lastLoc.lineNumber));

writeBase64VLQ(*sourceMap, int32_t(loc.columnNumber - lastLoc.columnNumber));

lastLoc = loc;

lastOffset = offset;

}

*sourceMap << "\"}";

}

void WasmBinaryWriter::writeEarlyUserSections() {

// The dylink section must be the first in the module, per

// the spec, to allow simple parsing by loaders.

for (auto& section : wasm->userSections) {

if (section.name == BinaryConsts::UserSections::Dylink) {

writeUserSection(section);

}

}

}

void WasmBinaryWriter::writeLateUserSections() {

for (auto& section : wasm->userSections) {

if (section.name != BinaryConsts::UserSections::Dylink) {

writeUserSection(section);

}

}

}

void WasmBinaryWriter::writeUserSection(const UserSection& section) {

auto start = startSection(0);

writeInlineString(section.name.c_str());

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

o << uint8_t(section.data[i]);

}

finishSection(start);

}

void WasmBinaryWriter::writeDebugLocation(const Function::DebugLocation& loc) {

if (loc == lastDebugLocation) {

return;

}

auto offset = o.size();

sourceMapLocations.emplace_back(offset, &loc);

lastDebugLocation = loc;

}

void WasmBinaryWriter::writeDebugLocation(Expression* curr, Function* func) {

auto& debugLocations = func->debugLocations;

auto iter = debugLocations.find(curr);

if (iter != debugLocations.end()) {

writeDebugLocation(iter->second);

}

}

void WasmBinaryWriter::writeInlineString(const char* name) {

int32_t size = strlen(name);

o << U32LEB(size);

for (int32_t i = 0; i < size; i++) {

o << int8_t(name[i]);

}

}

static bool isHexDigit(char ch) {

return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');

}

static int decodeHexNibble(char ch) {

return ch <= '9' ? ch & 15 : (ch & 15) + 9;

}

void WasmBinaryWriter::writeEscapedName(const char* name) {

if (!strpbrk(name, "\\")) {

writeInlineString(name);

return;

}

// decode escaped by escapeName (see below) function names

std::string unescaped;

int32_t size = strlen(name);

for (int32_t i = 0; i < size;) {

char ch = name[i++];

// support only `\xx` escapes; ignore invalid or unsupported escapes

if (ch != '\\' || i + 1 >= size || !isHexDigit(name[i]) || !isHexDigit(name[i + 1])) {

unescaped.push_back(ch);

continue;

}

unescaped.push_back(char((decodeHexNibble(name[i]) << 4) | decodeHexNibble(name[i + 1])));

i += 2;

}

writeInlineString(unescaped.c_str());

}

void WasmBinaryWriter::writeInlineBuffer(const char* data, size_t size) {

o << U32LEB(size);

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

o << int8_t(data[i]);

}

}

void WasmBinaryWriter::emitBuffer(const char* data, size_t size) {

assert(size > 0);

buffersToWrite.emplace_back(data, size, o.size());

o << uint32_t(0); // placeholder, we'll fill in the pointer to the buffer later when we have it

}

void WasmBinaryWriter::emitString(const char *str) {

if (debug) std::cerr << "emitString " << str << std::endl;

emitBuffer(str, strlen(str) + 1);

}

void WasmBinaryWriter::finishUp() {

if (debug) std::cerr << "finishUp" << std::endl;

// finish buffers

for (const auto& buffer : buffersToWrite) {

if (debug) std::cerr << "writing buffer" << (int)buffer.data[0] << "," << (int)buffer.data[1] << " at " << o.size() << " and pointer is at " << buffer.pointerLocation << std::endl;

o.writeAt(buffer.pointerLocation, (uint32_t)o.size());

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

o << (uint8_t)buffer.data[i];

}

}

}

// reader

void WasmBinaryBuilder::read() {

readHeader();

readSourceMapHeader();

// read sections until the end

while (more()) {

uint32_t sectionCode = getU32LEB();

uint32_t payloadLen = getU32LEB();

if (pos + payloadLen > input.size()) throwError("Section extends beyond end of input");

auto oldPos = pos;

// note the section in the list of seen sections, as almost no sections can appear more than once,

// and verify those that shouldn't do not.

if (sectionCode != BinaryConsts::Section::User && sectionCode != BinaryConsts::Section::Code) {

if (!seenSections.insert(BinaryConsts::Section(sectionCode)).second) {

throwError("section seen more than once: " + std::to_string(sectionCode));

}

}

switch (sectionCode) {

case BinaryConsts::Section::Start: readStart(); break;

case BinaryConsts::Section::Memory: readMemory(); break;

case BinaryConsts::Section::Type: readSignatures(); break;

case BinaryConsts::Section::Import: readImports(); break;

case BinaryConsts::Section::Function: readFunctionSignatures(); break;

case BinaryConsts::Section::Code: readFunctions(); break;

case BinaryConsts::Section::Export: readExports(); break;

case BinaryConsts::Section::Element: readTableElements(); break;

case BinaryConsts::Section::Global: {

readGlobals();

// imports can read global imports, so we run getGlobalName and create the mapping

// but after we read globals, we need to add the internal globals too, so do that here

mappedGlobals.clear(); // wipe the mapping

getGlobalName(-1); // force rebuild

break;

}

case BinaryConsts::Section::Data: readDataSegments(); break;

case BinaryConsts::Section::Table: readFunctionTableDeclaration(); break;

default: {

readUserSection(payloadLen);

if (pos > oldPos + payloadLen) {

throwError("bad user section size, started at " + std::to_string(oldPos) + " plus payload " + std::to_string(payloadLen) + " not being equal to new position " + std::to_string(pos));

}

pos = oldPos + payloadLen;

}

}

// make sure we advanced exactly past this section

if (pos != oldPos + payloadLen) {

throwError("bad section size, started at " + std::to_string(oldPos) + " plus payload " + std::to_string(payloadLen) + " not being equal to new position " + std::to_string(pos));

}

}

processFunctions();

}

void WasmBinaryBuilder::readUserSection(size_t payloadLen) {

auto oldPos = pos;

Name sectionName = getInlineString();

if (sectionName.equals(BinaryConsts::UserSections::Name)) {

readNames(payloadLen - (pos - oldPos));

} else {

// an unfamiliar custom section

if (sectionName.equals(BinaryConsts::UserSections::Linking)) {

std::cerr << "warning: linking section is present, which binaryen cannot handle yet - relocations will be invalidated!\n";

}

wasm.userSections.resize(wasm.userSections.size() + 1);

auto& section = wasm.userSections.back();

section.name = sectionName.str;

auto sectionSize = payloadLen - (pos - oldPos);

section.data.resize(sectionSize);

for (size_t i = 0; i < sectionSize; i++) {

section.data[i] = getInt8();

}

}

}

uint8_t WasmBinaryBuilder::getInt8() {

if (!more()) throwError("unexpected end of input");

if (debug) std::cerr << "getInt8: " << (int)(uint8_t)input[pos] << " (at " << pos << ")" << std::endl;

return input[pos++];

}

uint16_t WasmBinaryBuilder::getInt16() {

if (debug) std::cerr << "<==" << std::endl;

auto ret = uint16_t(getInt8());

ret |= uint16_t(getInt8()) << 8;

if (debug) std::cerr << "getInt16: " << ret << "/0x" << std::hex << ret << std::dec << " ==>" << std::endl;

return ret;

}

uint32_t WasmBinaryBuilder::getInt32() {

if (debug) std::cerr << "<==" << std::endl;

auto ret = uint32_t(getInt16());

ret |= uint32_t(getInt16()) << 16;

if (debug) std::cerr << "getInt32: " << ret << "/0x" << std::hex << ret << std::dec <<" ==>" << std::endl;

return ret;

}

uint64_t WasmBinaryBuilder::getInt64() {

if (debug) std::cerr << "<==" << std::endl;

auto ret = uint64_t(getInt32());

ret |= uint64_t(getInt32()) << 32;

if (debug) std::cerr << "getInt64: " << ret << "/0x" << std::hex << ret << std::dec << " ==>" << std::endl;

return ret;

}

uint8_t WasmBinaryBuilder::getLaneIndex(size_t lanes) {

if (debug) std::cerr << "<==" << std::endl;

auto ret = getInt8();

if (ret >= lanes) throwError("Illegal lane index");

if (debug) std::cerr << "getLaneIndex(" << lanes << "): " << ret << " ==>" << std::endl;

return ret;

}

Literal WasmBinaryBuilder::getFloat32Literal() {

if (debug) std::cerr << "<==" << std::endl;

auto ret = Literal(getInt32());

ret = ret.castToF32();

if (debug) std::cerr << "getFloat32: " << ret << " ==>" << std::endl;

return ret;

}

Literal WasmBinaryBuilder::getFloat64Literal() {

if (debug) std::cerr << "<==" << std::endl;

auto ret = Literal(getInt64());

ret = ret.castToF64();

if (debug) std::cerr << "getFloat64: " << ret << " ==>" << std::endl;

return ret;

}

Literal WasmBinaryBuilder::getVec128Literal() {

if (debug) std::cerr << "<==" << std::endl;

std::array<uint8_t, 16> bytes;

for (auto i = 0; i < 16; ++i) {

bytes[i] = getInt8();

}

auto ret = Literal(bytes.data());

if (debug) std::cerr << "getVec128: " << ret << " ==>" << std::endl;

return ret;

}

uint32_t WasmBinaryBuilder::getU32LEB() {

if (debug) std::cerr << "<==" << std::endl;

U32LEB ret;

ret.read([&]() {

return getInt8();

});

if (debug) std::cerr << "getU32LEB: " << ret.value << " ==>" << std::endl;

return ret.value;

}

uint64_t WasmBinaryBuilder::getU64LEB() {

if (debug) std::cerr << "<==" << std::endl;

U64LEB ret;

ret.read([&]() {

return getInt8();

});

if (debug) std::cerr << "getU64LEB: " << ret.value << " ==>" << std::endl;

return ret.value;

}

int32_t WasmBinaryBuilder::getS32LEB() {

if (debug) std::cerr << "<==" << std::endl;

S32LEB ret;

ret.read([&]() {

return (int8_t)getInt8();

});

if (debug) std::cerr << "getS32LEB: " << ret.value << " ==>" << std::endl;

return ret.value;

}

int64_t WasmBinaryBuilder::getS64LEB() {

if (debug) std::cerr << "<==" << std::endl;

S64LEB ret;

ret.read([&]() {

return (int8_t)getInt8();

});

if (debug) std::cerr << "getS64LEB: " << ret.value << " ==>" << std::endl;

return ret.value;

}

Type WasmBinaryBuilder::getType() {

int type = getS32LEB();

switch (type) {

// None only used for block signatures. TODO: Separate out?

case BinaryConsts::EncodedType::Empty: return none;

case BinaryConsts::EncodedType::i32: return i32;

case BinaryConsts::EncodedType::i64: return i64;

case BinaryConsts::EncodedType::f32: return f32;

case BinaryConsts::EncodedType::f64: return f64;

case BinaryConsts::EncodedType::v128: return v128;

case BinaryConsts::EncodedType::AnyFunc:

case BinaryConsts::EncodedType::Func:

throwError("invalid wasm type: " + std::to_string(type));

}

WASM_UNREACHABLE();

}

Type WasmBinaryBuilder::getConcreteType() {

auto type = getType();

if (!isConcreteType(type)) {

throw ParseException("non-concrete type when one expected");

}

return type;

}

Name WasmBinaryBuilder::getString() {

if (debug) std::cerr << "<==" << std::endl;

size_t offset = getInt32();

Name ret = cashew::IString((&input[0]) + offset, false);

if (debug) std::cerr << "getString: " << ret << " ==>" << std::endl;

return ret;

}

Name WasmBinaryBuilder::getInlineString() {

if (debug) std::cerr << "<==" << std::endl;

auto len = getU32LEB();

std::string str;

for (size_t i = 0; i < len; i++) {

auto curr = char(getInt8());

if (curr == 0) {

throwError("inline string contains NULL (0). that is technically valid in wasm, but you shouldn't do it, and it's not supported in binaryen");

}

str = str + curr;

}

if (debug) std::cerr << "getInlineString: " << str << " ==>" << std::endl;

return Name(str);

}

void WasmBinaryBuilder::verifyInt8(int8_t x) {

int8_t y = getInt8();

if (x != y) throwError("surprising value");

}

void WasmBinaryBuilder::verifyInt16(int16_t x) {

int16_t y = getInt16();

if (x != y) throwError("surprising value");

}

void WasmBinaryBuilder::verifyInt32(int32_t x) {

int32_t y = getInt32();

if (x != y) throwError("surprising value");

}

void WasmBinaryBuilder::verifyInt64(int64_t x) {

int64_t y = getInt64();

if (x != y) throwError("surprising value");

}

void WasmBinaryBuilder::ungetInt8() {

assert(pos > 0);

if (debug) std::cerr << "ungetInt8 (at " << pos << ")" << std::endl;

pos--;

}

void WasmBinaryBuilder::readHeader() {

if (debug) std::cerr << "== readHeader" << std::endl;

verifyInt32(BinaryConsts::Magic);

verifyInt32(BinaryConsts::Version);

}

void WasmBinaryBuilder::readStart() {

if (debug) std::cerr << "== readStart" << std::endl;

startIndex = getU32LEB();

}

void WasmBinaryBuilder::readMemory() {

if (debug) std::cerr << "== readMemory" << std::endl;

auto numMemories = getU32LEB();

if (!numMemories) return;

if (numMemories != 1) {

throwError("Must be exactly 1 memory");

}

if (wasm.memory.exists) {

throwError("Memory cannot be both imported and defined");

}

wasm.memory.exists = true;

getResizableLimits(wasm.memory.initial, wasm.memory.max, wasm.memory.shared, Memory::kUnlimitedSize);

}

void WasmBinaryBuilder::readSignatures() {

if (debug) std::cerr << "== readSignatures" << std::endl;

size_t numTypes = getU32LEB();

if (debug) std::cerr << "num: " << numTypes << std::endl;

for (size_t i = 0; i < numTypes; i++) {

if (debug) std::cerr << "read one" << std::endl;

auto curr = new FunctionType;

auto form = getS32LEB();

if (form != BinaryConsts::EncodedType::Func) {

throwError("bad signature form " + std::to_string(form));

}

size_t numParams = getU32LEB();

if (debug) std::cerr << "num params: " << numParams << std::endl;

for (size_t j = 0; j < numParams; j++) {

curr->params.push_back(getConcreteType());

}

auto numResults = getU32LEB();

if (numResults == 0) {

curr->result = none;

} else {

if (numResults != 1) {

throwError("signature must have 1 result");

}

curr->result = getType();

}

curr->name = Name::fromInt(wasm.functionTypes.size());

wasm.addFunctionType(curr);

}

}

Name WasmBinaryBuilder::getFunctionIndexName(Index i) {

return wasm.functions[i]->name;

}

void WasmBinaryBuilder::getResizableLimits(Address& initial, Address& max, bool &shared, Address defaultIfNoMax) {

auto flags = getU32LEB();

initial = getU32LEB();

bool hasMax = (flags & BinaryConsts::HasMaximum) != 0;

bool isShared = (flags & BinaryConsts::IsShared) != 0;

if (isShared && !hasMax) throwError("shared memory must have max size");

shared = isShared;

if (hasMax) max = getU32LEB();

else max = defaultIfNoMax;

}

void WasmBinaryBuilder::readImports() {

if (debug) std::cerr << "== readImports" << std::endl;

size_t num = getU32LEB();

if (debug) std::cerr << "num: " << num << std::endl;

Builder builder(wasm);

for (size_t i = 0; i < num; i++) {

if (debug) std::cerr << "read one" << std::endl;

auto module = getInlineString();

auto base = getInlineString();

auto kind = (ExternalKind)getU32LEB();

// We set a unique prefix for the name based on the kind. This ensures no collisions

// between them, which can't occur here (due to the index i) but could occur later

// due to the names section.

switch (kind) {

case ExternalKind::Function: {

auto name = Name(std::string("fimport$") + std::to_string(i));

auto index = getU32LEB();

if (index >= wasm.functionTypes.size()) {

throwError("invalid function index " + std::to_string(index) + " / " + std::to_string(wasm.functionTypes.size()));

}

auto* functionType = wasm.functionTypes[index].get();

auto params = functionType->params;