// Copyright 2015 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#include "src/wasm/module-decoder.h"

#include "src/base/functional.h"

#include "src/base/platform/platform.h"

#include "src/base/template-utils.h"

#include "src/counters.h"

#include "src/flags.h"

#include "src/macro-assembler.h"

#include "src/objects-inl.h"

#include "src/ostreams.h"

#include "src/v8.h"

#include "src/wasm/decoder.h"

#include "src/wasm/function-body-decoder-impl.h"

#include "src/wasm/wasm-limits.h"

namespace v8 {

namespace internal {

namespace wasm {

#if DEBUG

#define TRACE(...) \

do { \

if (FLAG_trace_wasm_decoder) PrintF(__VA_ARGS__); \

} while (false)

#else

#define TRACE(...)

#endif

namespace {

constexpr char kNameString[] = "name";

constexpr char kExceptionString[] = "exception";

constexpr char kUnknownString[] = "<unknown>";

template <size_t N>

constexpr size_t num_chars(const char (&)[N]) {

return N - 1; // remove null character at end.

}

} // namespace

const char* SectionName(SectionCode code) {

switch (code) {

case kUnknownSectionCode:

return "Unknown";

case kTypeSectionCode:

return "Type";

case kImportSectionCode:

return "Import";

case kFunctionSectionCode:

return "Function";

case kTableSectionCode:

return "Table";

case kMemorySectionCode:

return "Memory";

case kGlobalSectionCode:

return "Global";

case kExportSectionCode:

return "Export";

case kStartSectionCode:

return "Start";

case kCodeSectionCode:

return "Code";

case kElementSectionCode:

return "Element";

case kDataSectionCode:

return "Data";

case kNameSectionCode:

return kNameString;

case kExceptionSectionCode:

if (FLAG_experimental_wasm_eh) return kExceptionString;

return kUnknownString;

default:

return kUnknownString;

}

}

namespace {

ValueType TypeOf(const WasmModule* module, const WasmInitExpr& expr) {

switch (expr.kind) {

case WasmInitExpr::kNone:

return kWasmStmt;

case WasmInitExpr::kGlobalIndex:

return expr.val.global_index < module->globals.size()

? module->globals[expr.val.global_index].type

: kWasmStmt;

case WasmInitExpr::kI32Const:

return kWasmI32;

case WasmInitExpr::kI64Const:

return kWasmI64;

case WasmInitExpr::kF32Const:

return kWasmF32;

case WasmInitExpr::kF64Const:

return kWasmF64;

default:

UNREACHABLE();

}

}

// Reads a length-prefixed string, checking that it is within bounds. Returns

// the offset of the string, and the length as an out parameter.

WireBytesRef consume_string(Decoder& decoder, bool validate_utf8,

const char* name) {

uint32_t length = decoder.consume_u32v("string length");

uint32_t offset = decoder.pc_offset();

const byte* string_start = decoder.pc();

// Consume bytes before validation to guarantee that the string is not oob.

if (length > 0) {

decoder.consume_bytes(length, name);

if (decoder.ok() && validate_utf8 &&

!unibrow::Utf8::ValidateEncoding(string_start, length)) {

decoder.errorf(string_start, "%s: no valid UTF-8 string", name);

}

}

return {offset, decoder.failed() ? 0 : length};

}

// An iterator over the sections in a wasm binary module.

// Automatically skips all unknown sections.

class WasmSectionIterator {

public:

explicit WasmSectionIterator(Decoder& decoder)

: decoder_(decoder),

section_code_(kUnknownSectionCode),

section_start_(decoder.pc()),

section_end_(decoder.pc()) {

next();

}

inline bool more() const { return decoder_.ok() && decoder_.more(); }

inline SectionCode section_code() const { return section_code_; }

inline const byte* section_start() const { return section_start_; }

inline uint32_t section_length() const {

return static_cast<uint32_t>(section_end_ - section_start_);

}

inline Vector<const uint8_t> payload() const {

return {payload_start_, payload_length()};

}

inline const byte* payload_start() const { return payload_start_; }

inline uint32_t payload_length() const {

return static_cast<uint32_t>(section_end_ - payload_start_);

}

inline const byte* section_end() const { return section_end_; }

// Advances to the next section, checking that decoding the current section

// stopped at {section_end_}.

void advance(bool move_to_section_end = false) {

if (move_to_section_end && decoder_.pc() < section_end_) {

decoder_.consume_bytes(

static_cast<uint32_t>(section_end_ - decoder_.pc()));

}

if (decoder_.pc() != section_end_) {

const char* msg = decoder_.pc() < section_end_ ? "shorter" : "longer";

decoder_.errorf(decoder_.pc(),

"section was %s than expected size "

"(%u bytes expected, %zu decoded)",

msg, section_length(),

static_cast<size_t>(decoder_.pc() - section_start_));

}

next();

}

private:

Decoder& decoder_;

SectionCode section_code_;

const byte* section_start_;

const byte* payload_start_;

const byte* section_end_;

// Reads the section code/name at the current position and sets up

// the embedder fields.

void next() {

if (!decoder_.more()) {

section_code_ = kUnknownSectionCode;

return;

}

section_start_ = decoder_.pc();

uint8_t section_code = decoder_.consume_u8("section code");

// Read and check the section size.

uint32_t section_length = decoder_.consume_u32v("section length");

payload_start_ = decoder_.pc();

if (decoder_.checkAvailable(section_length)) {

// Get the limit of the section within the module.

section_end_ = payload_start_ + section_length;

} else {

// The section would extend beyond the end of the module.

section_end_ = payload_start_;

}

if (section_code == kUnknownSectionCode) {

// Check for the known "name" section.

WireBytesRef string =

wasm::consume_string(decoder_, true, "section name");

if (decoder_.failed() || decoder_.pc() > section_end_) {

section_code_ = kUnknownSectionCode;

return;

}

const byte* section_name_start =

decoder_.start() + decoder_.GetBufferRelativeOffset(string.offset());

payload_start_ = decoder_.pc();

TRACE(" +%d section name : \"%.*s\"\n",

static_cast<int>(section_name_start - decoder_.start()),

string.length() < 20 ? string.length() : 20, section_name_start);

if (string.length() == num_chars(kNameString) &&

strncmp(reinterpret_cast<const char*>(section_name_start),

kNameString, num_chars(kNameString)) == 0) {

section_code = kNameSectionCode;

}

} else if (!IsValidSectionCode(section_code)) {

decoder_.errorf(decoder_.pc(), "unknown section code #0x%02x",

section_code);

section_code = kUnknownSectionCode;

}

section_code_ = decoder_.failed() ? kUnknownSectionCode

: static_cast<SectionCode>(section_code);

if (section_code_ == kUnknownSectionCode && section_end_ > decoder_.pc()) {

// skip to the end of the unknown section.

uint32_t remaining = static_cast<uint32_t>(section_end_ - decoder_.pc());

decoder_.consume_bytes(remaining, "section payload");

}

}

};

} // namespace

// The main logic for decoding the bytes of a module.

class ModuleDecoderImpl : public Decoder {

public:

explicit ModuleDecoderImpl(ModuleOrigin origin)

: Decoder(nullptr, nullptr),

origin_(FLAG_assume_asmjs_origin ? kAsmJsOrigin : origin) {}

ModuleDecoderImpl(const byte* module_start, const byte* module_end,

ModuleOrigin origin)

: Decoder(module_start, module_end),

origin_(FLAG_assume_asmjs_origin ? kAsmJsOrigin : origin) {

if (end_ < start_) {

error(start_, "end is less than start");

end_ = start_;

}

}

virtual void onFirstError() {

pc_ = end_; // On error, terminate section decoding loop.

}

void DumpModule(const ModuleResult& result) {

std::string path;

if (FLAG_dump_wasm_module_path) {

path = FLAG_dump_wasm_module_path;

if (path.size() &&

!base::OS::isDirectorySeparator(path[path.size() - 1])) {

path += base::OS::DirectorySeparator();

}

}

// File are named `HASH.{ok,failed}.wasm`.

size_t hash = base::hash_range(start_, end_);

EmbeddedVector<char, 32> buf;

SNPrintF(buf, "%016zx.%s.wasm", hash, result.ok() ? "ok" : "failed");

std::string name(buf.start());

if (FILE* wasm_file = base::OS::FOpen((path + name).c_str(), "wb")) {

if (fwrite(start_, end_ - start_, 1, wasm_file) != 1) {

OFStream os(stderr);

os << "Error while dumping wasm file" << std::endl;

}

fclose(wasm_file);

}

}

void StartDecoding(Isolate* isolate) {

CHECK_NULL(module_);

SetCounters(isolate->counters());

module_.reset(new WasmModule(

base::make_unique<Zone>(isolate->allocator(), "signatures")));

module_->initial_pages = 0;

module_->maximum_pages = 0;

module_->mem_export = false;

module_->set_origin(origin_);

}

void DecodeModuleHeader(Vector<const uint8_t> bytes, uint8_t offset) {

if (failed()) return;

Reset(bytes, offset);

const byte* pos = pc_;

uint32_t magic_word = consume_u32("wasm magic");

#define BYTES(x) (x & 0xff), (x >> 8) & 0xff, (x >> 16) & 0xff, (x >> 24) & 0xff

if (magic_word != kWasmMagic) {

errorf(pos,

"expected magic word %02x %02x %02x %02x, "

"found %02x %02x %02x %02x",

BYTES(kWasmMagic), BYTES(magic_word));

}

pos = pc_;

{

uint32_t magic_version = consume_u32("wasm version");

if (magic_version != kWasmVersion) {

errorf(pos,

"expected version %02x %02x %02x %02x, "

"found %02x %02x %02x %02x",

BYTES(kWasmVersion), BYTES(magic_version));

}

}

#undef BYTES

}

void DecodeSection(SectionCode section_code, Vector<const uint8_t> bytes,

uint32_t offset, bool verify_functions = true) {

if (failed()) return;

Reset(bytes, offset);

TRACE("Section: %s\n", SectionName(section_code));

TRACE("Decode Section %p - %p\n", static_cast<const void*>(bytes.begin()),

static_cast<const void*>(bytes.end()));

// Check if the section is out-of-order.

if (section_code < next_section_) {

errorf(pc(), "unexpected section: %s", SectionName(section_code));

return;

}

switch (section_code) {

case kUnknownSectionCode:

break;

case kExceptionSectionCode:

// Note: kExceptionSectionCode > kCodeSectionCode, but must appear

// before the code section. Hence, treat it as a special case.

if (++number_of_exception_sections > 1) {

errorf(pc(), "Multiple exception sections not allowed");

return;

} else if (next_section_ >= kCodeSectionCode) {

errorf(pc(), "Exception section must appear before the code section");

return;

}

break;

default:

next_section_ = section_code;

++next_section_;

break;

}

switch (section_code) {

case kUnknownSectionCode:

break;

case kTypeSectionCode:

DecodeTypeSection();

break;

case kImportSectionCode:

DecodeImportSection();

break;

case kFunctionSectionCode:

DecodeFunctionSection();

break;

case kTableSectionCode:

DecodeTableSection();

break;

case kMemorySectionCode:

DecodeMemorySection();

break;

case kGlobalSectionCode:

DecodeGlobalSection();

break;

case kExportSectionCode:

DecodeExportSection();

break;

case kStartSectionCode:

DecodeStartSection();

break;

case kCodeSectionCode:

DecodeCodeSection(verify_functions);

break;

case kElementSectionCode:

DecodeElementSection();

break;

case kDataSectionCode:

DecodeDataSection();

break;

case kNameSectionCode:

DecodeNameSection();

break;

case kExceptionSectionCode:

if (FLAG_experimental_wasm_eh) {

DecodeExceptionSection();

} else {

errorf(pc(), "unexpected section: %s", SectionName(section_code));

}

break;

default:

errorf(pc(), "unexpected section: %s", SectionName(section_code));

return;

}

if (pc() != bytes.end()) {

const char* msg = pc() < bytes.end() ? "shorter" : "longer";

errorf(pc(),

"section was %s than expected size "

"(%zu bytes expected, %zu decoded)",

msg, bytes.size(), static_cast<size_t>(pc() - bytes.begin()));

}

}

void DecodeTypeSection() {

uint32_t signatures_count = consume_count("types count", kV8MaxWasmTypes);

module_->signatures.reserve(signatures_count);

for (uint32_t i = 0; ok() && i < signatures_count; ++i) {

TRACE("DecodeSignature[%d] module+%d\n", i,

static_cast<int>(pc_ - start_));

FunctionSig* s = consume_sig(module_->signature_zone.get());

module_->signatures.push_back(s);

uint32_t id = s ? module_->signature_map.FindOrInsert(s) : 0;

module_->signature_ids.push_back(id);

}

module_->signature_map.Freeze();

}

void DecodeImportSection() {

uint32_t import_table_count =

consume_count("imports count", kV8MaxWasmImports);

module_->import_table.reserve(import_table_count);

for (uint32_t i = 0; ok() && i < import_table_count; ++i) {

TRACE("DecodeImportTable[%d] module+%d\n", i,

static_cast<int>(pc_ - start_));

module_->import_table.push_back({

{0, 0}, // module_name

{0, 0}, // field_name

kExternalFunction, // kind

0 // index

});

WasmImport* import = &module_->import_table.back();

const byte* pos = pc_;

import->module_name = consume_string(true, "module name");

import->field_name = consume_string(true, "field name");

import->kind = static_cast<WasmExternalKind>(consume_u8("import kind"));

switch (import->kind) {

case kExternalFunction: {

// ===== Imported function =======================================

import->index = static_cast<uint32_t>(module_->functions.size());

module_->num_imported_functions++;

module_->functions.push_back({nullptr, // sig

import->index, // func_index

0, // sig_index

{0, 0}, // name_offset

{0, 0}, // code

true, // imported

false}); // exported

WasmFunction* function = &module_->functions.back();

function->sig_index =

consume_sig_index(module_.get(), &function->sig);

break;

}

case kExternalTable: {

// ===== Imported table ==========================================

if (!AddTable(module_.get())) break;

import->index =

static_cast<uint32_t>(module_->function_tables.size());

module_->function_tables.emplace_back();

WasmIndirectFunctionTable* table = &module_->function_tables.back();

table->imported = true;

expect_u8("element type", kWasmAnyFunctionTypeForm);

consume_resizable_limits(

"element count", "elements", FLAG_wasm_max_table_size,

&table->initial_size, &table->has_maximum_size,

FLAG_wasm_max_table_size, &table->maximum_size);

break;

}

case kExternalMemory: {

// ===== Imported memory =========================================

if (!AddMemory(module_.get())) break;

consume_resizable_limits(

"memory", "pages", FLAG_wasm_max_mem_pages,

&module_->initial_pages, &module_->has_maximum_pages,

kSpecMaxWasmMemoryPages, &module_->maximum_pages,

&module_->has_shared_memory);

break;

}

case kExternalGlobal: {

// ===== Imported global =========================================

import->index = static_cast<uint32_t>(module_->globals.size());

module_->globals.push_back(

{kWasmStmt, false, WasmInitExpr(), 0, true, false});

WasmGlobal* global = &module_->globals.back();

global->type = consume_value_type();

global->mutability = consume_mutability();

if (global->mutability) {

error("mutable globals cannot be imported");

}

break;

}

default:

errorf(pos, "unknown import kind 0x%02x", import->kind);

break;

}

}

}

void DecodeFunctionSection() {

uint32_t functions_count =

consume_count("functions count", kV8MaxWasmFunctions);

(IsWasm() ? GetCounters()->wasm_functions_per_wasm_module()

: GetCounters()->wasm_functions_per_asm_module())

->AddSample(static_cast<int>(functions_count));

module_->functions.reserve(functions_count);

module_->num_declared_functions = functions_count;

for (uint32_t i = 0; ok() && i < functions_count; ++i) {

uint32_t func_index = static_cast<uint32_t>(module_->functions.size());

module_->functions.push_back({nullptr, // sig

func_index, // func_index

0, // sig_index

{0, 0}, // name

{0, 0}, // code

false, // imported

false}); // exported

WasmFunction* function = &module_->functions.back();

function->sig_index = consume_sig_index(module_.get(), &function->sig);

}

}

void DecodeTableSection() {

uint32_t table_count = consume_count("table count", kV8MaxWasmTables);

for (uint32_t i = 0; ok() && i < table_count; i++) {

if (!AddTable(module_.get())) break;

module_->function_tables.emplace_back();

WasmIndirectFunctionTable* table = &module_->function_tables.back();

expect_u8("table type", kWasmAnyFunctionTypeForm);

consume_resizable_limits("table elements", "elements",

FLAG_wasm_max_table_size, &table->initial_size,

&table->has_maximum_size,

FLAG_wasm_max_table_size, &table->maximum_size);

}

}

void DecodeMemorySection() {

uint32_t memory_count = consume_count("memory count", kV8MaxWasmMemories);

for (uint32_t i = 0; ok() && i < memory_count; i++) {

if (!AddMemory(module_.get())) break;

consume_resizable_limits(

"memory", "pages", FLAG_wasm_max_mem_pages, &module_->initial_pages,

&module_->has_maximum_pages, kSpecMaxWasmMemoryPages,

&module_->maximum_pages, &module_->has_shared_memory);

}

}

void DecodeGlobalSection() {

uint32_t globals_count = consume_count("globals count", kV8MaxWasmGlobals);

uint32_t imported_globals = static_cast<uint32_t>(module_->globals.size());

module_->globals.reserve(imported_globals + globals_count);

for (uint32_t i = 0; ok() && i < globals_count; ++i) {

TRACE("DecodeGlobal[%d] module+%d\n", i, static_cast<int>(pc_ - start_));

// Add an uninitialized global and pass a pointer to it.

module_->globals.push_back(

{kWasmStmt, false, WasmInitExpr(), 0, false, false});

WasmGlobal* global = &module_->globals.back();

DecodeGlobalInModule(module_.get(), i + imported_globals, global);

}

if (ok()) CalculateGlobalOffsets(module_.get());

}

void DecodeExportSection() {

uint32_t export_table_count =

consume_count("exports count", kV8MaxWasmImports);

module_->export_table.reserve(export_table_count);

for (uint32_t i = 0; ok() && i < export_table_count; ++i) {

TRACE("DecodeExportTable[%d] module+%d\n", i,

static_cast<int>(pc_ - start_));

module_->export_table.push_back({

{0, 0}, // name

kExternalFunction, // kind

0 // index

});

WasmExport* exp = &module_->export_table.back();

exp->name = consume_string(true, "field name");

const byte* pos = pc();

exp->kind = static_cast<WasmExternalKind>(consume_u8("export kind"));

switch (exp->kind) {

case kExternalFunction: {

WasmFunction* func = nullptr;

exp->index = consume_func_index(module_.get(), &func);

module_->num_exported_functions++;

if (func) func->exported = true;

break;

}

case kExternalTable: {

WasmIndirectFunctionTable* table = nullptr;

exp->index = consume_table_index(module_.get(), &table);

if (table) table->exported = true;

break;

}

case kExternalMemory: {

uint32_t index = consume_u32v("memory index");

// TODO(titzer): This should become more regular

// once we support multiple memories.

if (!module_->has_memory || index != 0) {

error("invalid memory index != 0");

}

module_->mem_export = true;

break;

}

case kExternalGlobal: {

WasmGlobal* global = nullptr;

exp->index = consume_global_index(module_.get(), &global);

if (global) {

if (global->mutability) {

error("mutable globals cannot be exported");

}

global->exported = true;

}

break;

}

default:

errorf(pos, "invalid export kind 0x%02x", exp->kind);

break;

}

}

// Check for duplicate exports (except for asm.js).

if (ok() && origin_ != kAsmJsOrigin && module_->export_table.size() > 1) {

std::vector<WasmExport> sorted_exports(module_->export_table);

auto cmp_less = [this](const WasmExport& a, const WasmExport& b) {

// Return true if a < b.

if (a.name.length() != b.name.length()) {

return a.name.length() < b.name.length();

}

const byte* left = start() + GetBufferRelativeOffset(a.name.offset());

const byte* right = start() + GetBufferRelativeOffset(b.name.offset());

return memcmp(left, right, a.name.length()) < 0;

};

std::stable_sort(sorted_exports.begin(), sorted_exports.end(), cmp_less);

auto it = sorted_exports.begin();

WasmExport* last = &*it++;

for (auto end = sorted_exports.end(); it != end; last = &*it++) {

DCHECK(!cmp_less(*it, *last)); // Vector must be sorted.

if (!cmp_less(*last, *it)) {

const byte* pc = start() + GetBufferRelativeOffset(it->name.offset());

TruncatedUserString<> name(pc, it->name.length());

errorf(pc, "Duplicate export name '%.*s' for %s %d and %s %d",

name.length(), name.start(), ExternalKindName(last->kind),

last->index, ExternalKindName(it->kind), it->index);

break;

}

}

}

}

void DecodeStartSection() {

WasmFunction* func;

const byte* pos = pc_;

module_->start_function_index = consume_func_index(module_.get(), &func);

if (func &&

(func->sig->parameter_count() > 0 || func->sig->return_count() > 0)) {

error(pos, "invalid start function: non-zero parameter or return count");

}

}

void DecodeElementSection() {

uint32_t element_count =

consume_count("element count", FLAG_wasm_max_table_size);

if (element_count > 0 && module_->function_tables.size() == 0) {

error(pc_, "The element section requires a table");

}

for (uint32_t i = 0; ok() && i < element_count; ++i) {

const byte* pos = pc();

uint32_t table_index = consume_u32v("table index");

if (table_index != 0) {

errorf(pos, "illegal table index %u != 0", table_index);

}

if (table_index >= module_->function_tables.size()) {

errorf(pos, "out of bounds table index %u", table_index);

break;

}

WasmInitExpr offset = consume_init_expr(module_.get(), kWasmI32);

uint32_t num_elem =

consume_count("number of elements", kV8MaxWasmTableEntries);

module_->table_inits.emplace_back(table_index, offset);

WasmTableInit* init = &module_->table_inits.back();

for (uint32_t j = 0; j < num_elem; j++) {

WasmFunction* func = nullptr;

uint32_t index = consume_func_index(module_.get(), &func);

DCHECK_IMPLIES(ok(), func != nullptr);

if (!ok()) break;

DCHECK_EQ(index, func->func_index);

init->entries.push_back(index);

}

}

}

void DecodeCodeSection(bool verify_functions) {

uint32_t pos = pc_offset();

uint32_t functions_count = consume_u32v("functions count");

CheckFunctionsCount(functions_count, pos);

for (uint32_t i = 0; ok() && i < functions_count; ++i) {

const byte* pos = pc();

uint32_t size = consume_u32v("body size");

if (size > kV8MaxWasmFunctionSize) {

errorf(pos, "size %u > maximum function size %zu", size,

kV8MaxWasmFunctionSize);

return;

}

uint32_t offset = pc_offset();

consume_bytes(size, "function body");

if (failed()) break;

DecodeFunctionBody(i, size, offset, verify_functions);

}

}

bool CheckFunctionsCount(uint32_t functions_count, uint32_t offset) {

if (functions_count != module_->num_declared_functions) {

Reset(nullptr, nullptr, offset);

errorf(nullptr, "function body count %u mismatch (%u expected)",

functions_count, module_->num_declared_functions);

return false;

}

return true;

}

void DecodeFunctionBody(uint32_t index, uint32_t length, uint32_t offset,

bool verify_functions) {

WasmFunction* function =

&module_->functions[index + module_->num_imported_functions];

function->code = {offset, length};

if (verify_functions) {

ModuleWireBytes bytes(start_, end_);

VerifyFunctionBody(module_->signature_zone->allocator(),

index + module_->num_imported_functions, bytes,

module_.get(), function);

}

}

void DecodeDataSection() {

uint32_t data_segments_count =

consume_count("data segments count", kV8MaxWasmDataSegments);

module_->data_segments.reserve(data_segments_count);

for (uint32_t i = 0; ok() && i < data_segments_count; ++i) {

if (!module_->has_memory) {

error("cannot load data without memory");

break;

}

TRACE("DecodeDataSegment[%d] module+%d\n", i,

static_cast<int>(pc_ - start_));

module_->data_segments.push_back({

WasmInitExpr(), // dest_addr

{0, 0} // source

});

WasmDataSegment* segment = &module_->data_segments.back();

DecodeDataSegmentInModule(module_.get(), segment);

}

}

void DecodeNameSection() {

// TODO(titzer): find a way to report name errors as warnings.

// Use an inner decoder so that errors don't fail the outer decoder.

Decoder inner(start_, pc_, end_, buffer_offset_);

// Decode all name subsections.

// Be lenient with their order.

while (inner.ok() && inner.more()) {

uint8_t name_type = inner.consume_u8("name type");

if (name_type & 0x80) inner.error("name type if not varuint7");

uint32_t name_payload_len = inner.consume_u32v("name payload length");

if (!inner.checkAvailable(name_payload_len)) break;

// Decode function names, ignore the rest.

// Local names will be decoded when needed.

switch (name_type) {

case NameSectionType::kModule: {

WireBytesRef name = wasm::consume_string(inner, false, "module name");

if (inner.ok() && validate_utf8(&inner, name)) module_->name = name;

break;

}

case NameSectionType::kFunction: {

uint32_t functions_count = inner.consume_u32v("functions count");

for (; inner.ok() && functions_count > 0; --functions_count) {

uint32_t function_index = inner.consume_u32v("function index");

WireBytesRef name =

wasm::consume_string(inner, false, "function name");

// Be lenient with errors in the name section: Ignore illegal

// or out-of-order indexes and non-UTF8 names. You can even assign

// to the same function multiple times (last valid one wins).

if (inner.ok() && function_index < module_->functions.size() &&

validate_utf8(&inner, name)) {

module_->functions[function_index].name = name;

}

}

break;

}

default:

inner.consume_bytes(name_payload_len, "name subsection payload");

break;

}

}

// Skip the whole names section in the outer decoder.

consume_bytes(static_cast<uint32_t>(end_ - start_), nullptr);

}

void DecodeExceptionSection() {

uint32_t exception_count =

consume_count("exception count", kV8MaxWasmExceptions);

for (uint32_t i = 0; ok() && i < exception_count; ++i) {

TRACE("DecodeExceptionSignature[%d] module+%d\n", i,

static_cast<int>(pc_ - start_));

module_->exceptions.emplace_back(

consume_exception_sig(module_->signature_zone.get()));

}

}

ModuleResult FinishDecoding(bool verify_functions = true) {

if (ok()) {

CalculateGlobalOffsets(module_.get());

}

ModuleResult result = toResult(std::move(module_));

if (verify_functions && result.ok()) {

// Copy error code and location.

result.MoveErrorFrom(intermediate_result_);

}

if (FLAG_dump_wasm_module) DumpModule(result);

return result;

}

// Decodes an entire module.

ModuleResult DecodeModule(Isolate* isolate, bool verify_functions = true) {

StartDecoding(isolate);

uint32_t offset = 0;

DecodeModuleHeader(Vector<const uint8_t>(start(), end() - start()), offset);

if (failed()) {

return FinishDecoding(verify_functions);

}

// Size of the module header.

offset += 8;

Decoder decoder(start_ + offset, end_, offset);

WasmSectionIterator section_iter(decoder);

while (ok() && section_iter.more()) {

// Shift the offset by the section header length

offset += section_iter.payload_start() - section_iter.section_start();

if (section_iter.section_code() != SectionCode::kUnknownSectionCode) {

DecodeSection(section_iter.section_code(), section_iter.payload(),

offset, verify_functions);

}

// Shift the offset by the remaining section payload

offset += section_iter.payload_length();

section_iter.advance(true);

}

if (decoder.failed()) {

return decoder.toResult<std::unique_ptr<WasmModule>>(nullptr);

}

return FinishDecoding(verify_functions);

}

// Decodes a single anonymous function starting at {start_}.

FunctionResult DecodeSingleFunction(Zone* zone,

const ModuleWireBytes& wire_bytes,

const WasmModule* module,

std::unique_ptr<WasmFunction> function) {

pc_ = start_;

function->sig = consume_sig(zone);

function->name = {0, 0};

function->code = {off(pc_), static_cast<uint32_t>(end_ - pc_)};

if (ok())

VerifyFunctionBody(zone->allocator(), 0, wire_bytes, module,

function.get());

FunctionResult result(std::move(function));

// Copy error code and location.

result.MoveErrorFrom(intermediate_result_);

return result;

}

// Decodes a single function signature at {start}.

FunctionSig* DecodeFunctionSignature(Zone* zone, const byte* start) {

pc_ = start;

FunctionSig* result = consume_sig(zone);

return ok() ? result : nullptr;

}

WasmInitExpr DecodeInitExpr(const byte* start) {

pc_ = start;

return consume_init_expr(nullptr, kWasmStmt);

}

WasmModule* module() { return module_.get(); }

bool IsWasm() { return origin_ == kWasmOrigin; }

Counters* GetCounters() {

DCHECK_NOT_NULL(counters_);

return counters_;

}

void SetCounters(Counters* counters) {

DCHECK_NULL(counters_);

counters_ = counters;

}

private:

std::unique_ptr<WasmModule> module_;

Counters* counters_ = nullptr;

// The type section is the first section in a module.

uint8_t next_section_ = kFirstSectionInModule;

uint32_t number_of_exception_sections = 0;

// We store next_section_ as uint8_t instead of SectionCode so that we can

// increment it. This static_assert should make sure that SectionCode does not

// get bigger than uint8_t accidentially.

static_assert(sizeof(ModuleDecoderImpl::next_section_) == sizeof(SectionCode),

"type mismatch");

Result<bool> intermediate_result_;

ModuleOrigin origin_;

uint32_t off(const byte* ptr) {

return static_cast<uint32_t>(ptr - start_) + buffer_offset_;

}

bool AddTable(WasmModule* module) {

if (module->function_tables.size() > 0) {

error("At most one table is supported");

return false;

} else {

return true;

}

}

bool AddMemory(WasmModule* module) {

if (module->has_memory) {

error("At most one memory is supported");

return false;

} else {

module->has_memory = true;

return true;

}

}

// Decodes a single global entry inside a module starting at {pc_}.

void DecodeGlobalInModule(WasmModule* module, uint32_t index,

WasmGlobal* global) {

global->type = consume_value_type();

global->mutability = consume_mutability();

const byte* pos = pc();

global->init = consume_init_expr(module, kWasmStmt);

switch (global->init.kind) {

case WasmInitExpr::kGlobalIndex: {

uint32_t other_index = global->init.val.global_index;

if (other_index >= index) {

errorf(pos,

"invalid global index in init expression, "

"index %u, other_index %u",

index, other_index);

} else if (module->globals[other_index].type != global->type) {

errorf(pos,

"type mismatch in global initialization "

"(from global #%u), expected %s, got %s",

other_index, WasmOpcodes::TypeName(global->type),

WasmOpcodes::TypeName(module->globals[other_index].type));

}

break;

}

default:

if (global->type != TypeOf(module, global->init)) {

errorf(pos,

"type error in global initialization, expected %s, got %s",

WasmOpcodes::TypeName(global->type),

WasmOpcodes::TypeName(TypeOf(module, global->init)));

}

}

}

// Decodes a single data segment entry inside a module starting at {pc_}.

void DecodeDataSegmentInModule(WasmModule* module, WasmDataSegment* segment) {

expect_u8("linear memory index", 0);

segment->dest_addr = consume_init_expr(module, kWasmI32);

uint32_t source_length = consume_u32v("source size");

uint32_t source_offset = pc_offset();

consume_bytes(source_length, "segment data");