/*

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

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());

}

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

}

void WasmBinaryWriter::write() {

writeHeader();

writeEarlyUserSections();

initializeDebugInfo();

if (sourceMap) {

writeSourceMapProlog();

}

writeTypes();

writeImports();

writeFunctionSignatures();

writeFunctionTableDeclaration();

writeMemory();

writeGlobals();

writeEvents();

writeExports();

writeStart();

writeTableElements();

writeDataCount();

writeFunctions();

writeDataSegments();

if (debugInfo) {

writeNames();

}

if (sourceMap && !sourceMapUrl.empty()) {

writeSourceMapUrl();

}

if (symbolMap.size() > 0) {

writeSymbolMap();

}

if (sourceMap) {

writeSourceMapEpilog();

}

writeLateUserSections();

writeFeaturesSection();

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) {

// section size does not include the reserved bytes of the size field itself

int32_t size = o.size() - start - MaxLEB32Bytes;

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_);

});

ModuleUtils::iterImportedEvents(*wasm, [&](Event* event) {

if (debug) {

std::cerr << "write one event" << std::endl;

}

writeImportHeader(event);

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

o << U32LEB(event->attribute);

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

});

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;

case ExternalKind::Event:

o << U32LEB(getEventIndex(curr->value));

break;

default:

WASM_UNREACHABLE();

}

}

finishSection(start);

}

void WasmBinaryWriter::writeDataCount() {

if (!wasm->features.hasBulkMemory() || !wasm->memory.segments.size()) {

return;

}

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

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

finishSection(start);

}

void WasmBinaryWriter::writeDataSegments() {

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

return;

}

if (wasm->memory.segments.size() > WebLimitations::MaxDataSegments) {

std::cerr << "Some VMs may not accept this binary because it has a large "

<< "number of data segments. Run the limit-segments pass to "

<< "merge segments." << std::endl;

}

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

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

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

uint32_t flags = 0;

if (segment.isPassive) {

flags |= BinaryConsts::IsPassive;

}

o << U32LEB(flags);

if (!segment.isPassive) {

writeExpression(segment.offset);

o << int8_t(BinaryConsts::End);

}

writeInlineBuffer(segment.data.data(), segment.data.size());

}

finishSection(start);

}

uint32_t WasmBinaryWriter::getFunctionIndex(Name name) {

assert(indexes.functionIndexes.count(name));

return indexes.functionIndexes[name];

}

uint32_t WasmBinaryWriter::getGlobalIndex(Name name) {

assert(indexes.globalIndexes.count(name));

return indexes.globalIndexes[name];

}

uint32_t WasmBinaryWriter::getEventIndex(Name name) {

assert(indexes.eventIndexes.count(name));

return indexes.eventIndexes[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 || wasm->table.segments.size() == 0) {

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) {

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

o << U32LEB(0);

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::writeEvents() {

if (importInfo->getNumDefinedEvents() == 0) {

return;

}

if (debug) {

std::cerr << "== writeEvents" << std::endl;

}

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

auto num = importInfo->getNumDefinedEvents();

o << U32LEB(num);

ModuleUtils::iterDefinedEvents(*wasm, [&](Event* event) {

if (debug) {

std::cerr << "write one" << std::endl;

}

o << U32LEB(event->attribute);

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

});

finishSection(start);

}

void WasmBinaryWriter::writeNames() {

if (wasm->functions.empty()) {

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(indexes.functionIndexes.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 == indexes.functionIndexes.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(BinaryConsts::User);

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::writeFeaturesSection() {

if (!wasm->hasFeaturesSection || wasm->features.isMVP()) {

return;

}

// TODO(tlively): unify feature names with rest of toolchain and use

// FeatureSet::toString()

auto toString = [](FeatureSet::Feature f) {

switch (f) {

case FeatureSet::Atomics:

return BinaryConsts::UserSections::AtomicsFeature;

case FeatureSet::MutableGlobals:

return BinaryConsts::UserSections::MutableGlobalsFeature;

case FeatureSet::TruncSat:

return BinaryConsts::UserSections::TruncSatFeature;

case FeatureSet::SIMD:

return BinaryConsts::UserSections::SIMD128Feature;

case FeatureSet::BulkMemory:

return BinaryConsts::UserSections::BulkMemoryFeature;

case FeatureSet::SignExt:

return BinaryConsts::UserSections::SignExtFeature;

case FeatureSet::ExceptionHandling:

return BinaryConsts::UserSections::ExceptionHandlingFeature;

case FeatureSet::TailCall:

return BinaryConsts::UserSections::TailCallFeature;

default:

WASM_UNREACHABLE();

}

};

std::vector<const char*> features;

wasm->features.iterFeatures(

[&](FeatureSet::Feature f) { features.push_back(toString(f)); });

auto start = startSection(BinaryConsts::User);

writeInlineString(BinaryConsts::UserSections::TargetFeatures);

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

for (auto& f : features) {

o << uint8_t(BinaryConsts::FeatureUsed);

writeInlineString(f);

}

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());

// placeholder, we'll fill in the pointer to the buffer later when we have it

o << uint32_t(0);

}

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();

break;

case BinaryConsts::Section::Data:

readDataSegments();

break;

case BinaryConsts::Section::DataCount:

readDataCount();

break;

case BinaryConsts::Section::Table:

readFunctionTableDeclaration();

break;

case BinaryConsts::Section::Event:

readEvents();

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));

}

}

validateBinary();

processFunctions();

}

void WasmBinaryBuilder::readUserSection(size_t payloadLen) {

auto oldPos = pos;

Name sectionName = getInlineString();

size_t read = pos - oldPos;

if (read > payloadLen) {

throwError("bad user section size");

}

payloadLen -= read;

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

readNames(payloadLen);

} else if (sectionName.equals(BinaryConsts::UserSections::TargetFeatures)) {

readFeatures(payloadLen);

} else {

// an unfamiliar custom section

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

std::cerr

<< "warning: linking section is present, so this is not a standard "

"wasm file - binaryen cannot handle this properly!\n";

}

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

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

section.name = sectionName.str;

auto sectionSize = payloadLen;

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;

}