return unibrow::Utf8::ValidateEncoding(

decoder->start() + decoder->GetBufferRelativeOffset(string.offset()),

string.length());

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

WireBytesRef string = consume_string(decoder, true, "section name");

if (decoder->failed()) {

return kUnknownSectionCode;

}

const byte* section_name_start =

decoder->start() + decoder->GetBufferRelativeOffset(string.offset());

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

static_cast<int>(section_name_start - decoder->start()),

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

using SpecialSectionPair = std::pair<base::Vector<const char>, SectionCode>;

static constexpr SpecialSectionPair kSpecialSections[]{

{base::StaticCharVector(kNameString), kNameSectionCode},

{base::StaticCharVector(kSourceMappingURLString),

kSourceMappingURLSectionCode},

{base::StaticCharVector(kCompilationHintsString),

kCompilationHintsSectionCode},

{base::StaticCharVector(kBranchHintsString), kBranchHintsSectionCode},

{base::StaticCharVector(kDebugInfoString), kDebugInfoSectionCode},

{base::StaticCharVector(kExternalDebugInfoString),

kExternalDebugInfoSectionCode}};

auto name_vec = base::Vector<const char>::cast(

base::VectorOf(section_name_start, string.length()));

for (auto& special_section : kSpecialSections) {

if (name_vec == special_section.first) return special_section.second;

}

return kUnknownSectionCode;

public:

explicit WasmSectionIterator(Decoder* decoder)

: decoder_(decoder),

section_code_(kUnknownSectionCode),

section_start_(decoder->pc()),

section_end_(decoder->pc()) {

next();

}

bool more() const { return decoder_->ok() && decoder_->more(); }

SectionCode section_code() const { return section_code_; }

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

uint32_t section_length() const {

return static_cast<uint32_t>(section_end_ - section_start_);

}

base::Vector<const uint8_t> payload() const {

return {payload_start_, payload_length()};

}

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

uint32_t payload_length() const {

return static_cast<uint32_t>(section_end_ - payload_start_);

}

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", "sourceMappingURL", or "compilationHints"

// section.

// To identify the unknown section we set the end of the decoder bytes to

// the end of the custom section, so that we do not read the section name

// beyond the end of the section.

const byte* module_end = decoder_->end();

decoder_->set_end(section_end_);

section_code = IdentifyUnknownSectionInternal(decoder_);

if (decoder_->ok()) decoder_->set_end(module_end);

// As a side effect, the above function will forward the decoder to after

// the identifier string.

payload_start_ = decoder_->pc();

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

}

}

public:

explicit ModuleDecoderImpl(const WasmFeatures& enabled, ModuleOrigin origin)

: Decoder(nullptr, nullptr),

enabled_features_(enabled),

origin_(origin) {}

ModuleDecoderImpl(const WasmFeatures& enabled, const byte* module_start,

const byte* module_end, ModuleOrigin origin)

: Decoder(module_start, module_end),

enabled_features_(enabled),

module_start_(module_start),

module_end_(module_end),

origin_(origin) {

if (end_ < start_) {

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

end_ = start_;

}

}

void onFirstError() override {

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

}

void DumpModule(const base::Vector<const byte> module_bytes) {

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(module_bytes.begin(), module_bytes.end());

base::EmbeddedVector<char, 32> buf;

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

path += buf.begin();

size_t rv = 0;

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

rv = fwrite(module_bytes.begin(), module_bytes.length(), 1, file);

base::Fclose(file);

}

if (rv != 1) {

OFStream os(stderr);

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

}

}

void StartDecoding(Counters* counters, AccountingAllocator* allocator) {

CHECK_NULL(module_);

SetCounters(counters);

module_.reset(

new WasmModule(std::make_unique<Zone>(allocator, "signatures")));

module_->initial_pages = 0;

module_->maximum_pages = 0;

module_->mem_export = false;

module_->origin = origin_;

}

void DecodeModuleHeader(base::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

}

bool CheckSectionOrder(SectionCode section_code,

SectionCode prev_section_code,

SectionCode next_section_code) {

if (next_ordered_section_ > next_section_code) {

errorf(pc(), "The %s section must appear before the %s section",

SectionName(section_code), SectionName(next_section_code));

return false;

}

if (next_ordered_section_ <= prev_section_code) {

next_ordered_section_ = prev_section_code + 1;

}

return true;

}

bool CheckUnorderedSection(SectionCode section_code) {

if (has_seen_unordered_section(section_code)) {

errorf(pc(), "Multiple %s sections not allowed",

SectionName(section_code));

return false;

}

set_seen_unordered_section(section_code);

return true;

}

void DecodeSection(SectionCode section_code,

base::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", bytes.begin(), bytes.end());

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

if (section_code < next_ordered_section_ &&

section_code < kFirstUnorderedSection) {

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

return;

}

switch (section_code) {

case kUnknownSectionCode:

break;

case kDataCountSectionCode:

if (!CheckUnorderedSection(section_code)) return;

if (!CheckSectionOrder(section_code, kElementSectionCode,

kCodeSectionCode))

return;

break;

case kTagSectionCode:

if (!CheckUnorderedSection(section_code)) return;

if (!CheckSectionOrder(section_code, kMemorySectionCode,

kGlobalSectionCode))

return;

break;

case kNameSectionCode:

// TODO(titzer): report out of place name section as a warning.

// Be lenient with placement of name section. All except first

// occurrence are ignored.

case kSourceMappingURLSectionCode:

// sourceMappingURL is a custom section and currently can occur anywhere

// in the module. In case of multiple sourceMappingURL sections, all

// except the first occurrence are ignored.

case kDebugInfoSectionCode:

// .debug_info is a custom section containing core DWARF information

// if produced by compiler. Its presence likely means that Wasm was

// built in a debug mode.

case kExternalDebugInfoSectionCode:

// external_debug_info is a custom section containing a reference to an

// external symbol file.

case kCompilationHintsSectionCode:

// TODO(frgossen): report out of place compilation hints section as a

// warning.

// Be lenient with placement of compilation hints section. All except

// first occurrence after function section and before code section are

// ignored.

break;

case kBranchHintsSectionCode:

// TODO(yuri): report out of place branch hints section as a

// warning.

// Be lenient with placement of compilation hints section. All except

// first occurrence after function section and before code section are

// ignored.

break;

default:

next_ordered_section_ = section_code + 1;

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 kSourceMappingURLSectionCode:

DecodeSourceMappingURLSection();

break;

case kDebugInfoSectionCode:

// If there is an explicit source map, prefer it over DWARF info.

if (module_->debug_symbols.type == WasmDebugSymbols::Type::None) {

module_->debug_symbols = {WasmDebugSymbols::Type::EmbeddedDWARF, {}};

}

consume_bytes(static_cast<uint32_t>(end_ - start_), ".debug_info");

break;

case kExternalDebugInfoSectionCode:

DecodeExternalDebugInfoSection();

break;

case kCompilationHintsSectionCode:

if (enabled_features_.has_compilation_hints()) {

DecodeCompilationHintsSection();

} else {

// Ignore this section when feature was disabled. It is an optional

// custom section anyways.

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

}

break;

case kBranchHintsSectionCode:

if (enabled_features_.has_branch_hinting()) {

DecodeBranchHintsSection();

} else {

// Ignore this section when feature was disabled. It is an optional

// custom section anyways.

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

}

break;

case kDataCountSectionCode:

DecodeDataCountSection();

break;

case kTagSectionCode:

if (enabled_features_.has_eh()) {

DecodeTagSection();

} else {

errorf(pc(),

"unexpected section <%s> (enable with --experimental-wasm-eh)",

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 types_count = consume_count("types count", kV8MaxWasmTypes);

module_->types.reserve(types_count);

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

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

static_cast<int>(pc_ - start_));

uint8_t kind = consume_u8("type kind");

switch (kind) {

case kWasmFunctionTypeCode:

case kWasmFunctionSubtypeCode: {

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

uint32_t super_index = kNoSuperType;

if (kind == kWasmFunctionSubtypeCode) {

if (!enabled_features_.has_gc()) {

errorf(pc(),

"invalid function type definition, enable with "

"--experimental-wasm-gc");

break;

}

HeapType super_type = consume_super_type();

if (super_type == HeapType::kFunc) {

super_index = kGenericSuperType;

} else if (super_type.is_index()) {

super_index = super_type.representation();

} else {

errorf(pc(), "type %d: invalid supertype %d", i,

super_type.code());

break;

}

}

module_->add_signature(s, super_index);

break;

}

case kWasmStructTypeCode:

case kWasmStructSubtypeCode: {

if (!enabled_features_.has_gc()) {

errorf(pc(),

"invalid struct type definition, enable with "

"--experimental-wasm-gc");

break;

}

const StructType* s = consume_struct(module_->signature_zone.get());

uint32_t super_index = kNoSuperType;

if (kind == kWasmStructSubtypeCode) {

HeapType super_type = consume_super_type();

if (super_type == HeapType::kData) {

super_index = kGenericSuperType;

} else if (super_type.is_index()) {

super_index = super_type.representation();

} else {

errorf(pc(), "type %d: invalid supertype %d", i,

super_type.code());

break;

}

}

module_->add_struct_type(s, super_index);

// TODO(7748): Should we canonicalize struct types, like

// {signature_map} does for function signatures?

break;

}

case kWasmArrayTypeCode:

case kWasmArraySubtypeCode: {

if (!enabled_features_.has_gc()) {

errorf(pc(),

"invalid array type definition, enable with "

"--experimental-wasm-gc");

break;

}

const ArrayType* type = consume_array(module_->signature_zone.get());

uint32_t super_index = kNoSuperType;

if (kind == kWasmArraySubtypeCode) {

HeapType super_type = consume_super_type();

if (super_type == HeapType::kData) {

super_index = kGenericSuperType;

} else if (super_type.is_index()) {

super_index = super_type.representation();

} else {

errorf(pc(), "type %d: invalid supertype %d", i,

super_type.code());

break;

}

}

module_->add_array_type(type, super_index);

break;

}

default:

errorf(pc(), "unknown type form: %d", kind);

break;

}

}

// Check validity of explicitly defined supertypes.

const WasmModule* module = module_.get();

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

uint32_t explicit_super = module_->supertype(i);

if (explicit_super == kNoSuperType) continue;

if (explicit_super == kGenericSuperType) continue;

DCHECK_LT(explicit_super, types_count); // {consume_super_type} checks.

// Only types that have an explicit supertype themselves can be explicit

// supertypes of other types.

if (!module->has_supertype(explicit_super)) {

errorf("type %d has invalid explicit supertype %d", i, explicit_super);

continue;

}

int depth = GetSubtypingDepth(module, i);

if (depth > static_cast<int>(kV8MaxRttSubtypingDepth)) {

errorf("type %d: subtyping depth is greater than allowed", i);

continue;

}

if (depth == -1) {

errorf("type %d: cyclic inheritance", i);

continue;

}

switch (module_->type_kinds[i]) {

case kWasmStructTypeCode:

if (!module->has_struct(explicit_super)) break;

if (!StructIsSubtypeOf(i, explicit_super, module, module)) break;

continue;

case kWasmArrayTypeCode:

if (!module->has_array(explicit_super)) break;

if (!ArrayIsSubtypeOf(i, explicit_super, module, module)) break;

continue;

case kWasmFunctionTypeCode:

if (!module->has_signature(explicit_super)) break;

if (!FunctionIsSubtypeOf(i, explicit_super, module, module)) break;

continue;

default:

UNREACHABLE();

}

errorf("type %d has invalid explicit supertype %d", i, explicit_super);

}

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(this, true, "module name");

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

import->kind =

static_cast<ImportExportKindCode>(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}, // code

true, // imported

false, // exported

false}); // declared

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_->tables.size());

module_->num_imported_tables++;

module_->tables.emplace_back();

WasmTable* table = &module_->tables.back();

table->imported = true;

const byte* type_position = pc();

ValueType type = consume_reference_type();

if (!WasmTable::IsValidTableType(type, module_.get())) {

error(

type_position,

"Currently, only externref and function references are allowed "

"as table types");

break;

}

table->type = type;

uint8_t flags = validate_table_flags("element count");

consume_resizable_limits(

"element count", "elements", std::numeric_limits<uint32_t>::max(),

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

std::numeric_limits<uint32_t>::max(), &table->maximum_size,

flags);

break;

}

case kExternalMemory: {

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

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

uint8_t flags = validate_memory_flags(&module_->has_shared_memory,

&module_->is_memory64);

consume_resizable_limits(

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

&module_->has_maximum_pages, kSpecMaxMemoryPages,

&module_->maximum_pages, flags);

break;

}

case kExternalGlobal: {

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

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

module_->globals.push_back({kWasmVoid, false, {}, {0}, true, false});

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

global->type = consume_value_type();

global->mutability = consume_mutability();

if (global->mutability) {

module_->num_imported_mutable_globals++;

}

break;

}

case kExternalTag: {

// ===== Imported tag ================================================

if (!enabled_features_.has_eh()) {

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

break;

}

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

const WasmTagSig* tag_sig = nullptr;

consume_exception_attribute(); // Attribute ignored for now.

consume_tag_sig_index(module_.get(), &tag_sig);

module_->tags.emplace_back(tag_sig);

break;

}

default:

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

break;

}

}

}

void DecodeFunctionSection() {

uint32_t functions_count =

consume_count("functions count", kV8MaxWasmFunctions);

auto counter =

SELECT_WASM_COUNTER(GetCounters(), origin_, wasm_functions_per, module);

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

DCHECK_EQ(module_->functions.size(), module_->num_imported_functions);

uint32_t total_function_count =

module_->num_imported_functions + functions_count;

module_->functions.reserve(total_function_count);

module_->num_declared_functions = functions_count;

for (uint32_t i = 0; 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}, // code

false, // imported

false, // exported

false}); // declared

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

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

if (!ok()) return;

}

DCHECK_EQ(module_->functions.size(), total_function_count);

}

void DecodeTableSection() {

// TODO(ahaas): Set the correct limit to {kV8MaxWasmTables} once the

// implementation of ExternRef landed.

uint32_t max_count =

enabled_features_.has_reftypes() ? 100000 : kV8MaxWasmTables;

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

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

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

module_->tables.emplace_back();

WasmTable* table = &module_->tables.back();

const byte* type_position = pc();

ValueType table_type = consume_reference_type();

if (!WasmTable::IsValidTableType(table_type, module_.get())) {

error(type_position,

"Currently, only externref and function references are allowed "

"as table types");

continue;

}

table->type = table_type;

uint8_t flags = validate_table_flags("table elements");

consume_resizable_limits(

"table elements", "elements", std::numeric_limits<uint32_t>::max(),

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

std::numeric_limits<uint32_t>::max(), &table->maximum_size, flags);

if (!table_type.is_defaultable()) {

table->initial_value = consume_init_expr(module_.get(), table_type);

}

}

}

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;

uint8_t flags = validate_memory_flags(&module_->has_shared_memory,

&module_->is_memory64);

consume_resizable_limits("memory", "pages", kSpecMaxMemoryPages,

&module_->initial_pages,

&module_->has_maximum_pages, kSpecMaxMemoryPages,

&module_->maximum_pages, flags);

}

}

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

ValueType type = consume_value_type();

bool mutability = consume_mutability();

if (failed()) break;

WireBytesRef init = consume_init_expr(module_.get(), type);

module_->globals.push_back({type, mutability, init, {0}, false, false});

}

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

}

void DecodeExportSection() {

uint32_t export_table_count =

consume_count("exports count", kV8MaxWasmExports);

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(this, true, "field name");

const byte* pos = pc();

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

switch (exp->kind) {

case kExternalFunction: {

WasmFunction* func = nullptr;

exp->index =

consume_func_index(module_.get(), &func, "export function index");

if (failed()) break;

DCHECK_NOT_NULL(func);

module_->num_exported_functions++;

func->exported = true;

// Exported functions are considered "declared".

func->declared = true;

break;

}

case kExternalTable: {

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

global->exported = true;

}

break;

}

case kExternalTag: {

if (!enabled_features_.has_eh()) {

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

break;

}

WasmTag* tag = nullptr;

exp->index = consume_tag_index(module_.get(), &tag);

break;

}

default:

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

break;

}

}

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

if (ok() && origin_ == kWasmOrigin && 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, "start function index");

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

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

bool expressions_as_elements;

WasmElemSegment segment =

consume_element_segment_header(&expressions_as_elements);

if (failed()) return;