return unibrow::Utf8::ValidateEncoding(

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

string.length());

unibrow::Utf8Variant grammar,

const char* name, ITracer* tracer) {

if (tracer) {

tracer->Description(name);

tracer->Description(" ");

}

uint32_t length = decoder->consume_u32v("length", tracer);

if (tracer) {

tracer->Description(": ");

tracer->Description(length);

tracer->NextLine();

}

uint32_t offset = decoder->pc_offset();

const uint8_t* string_start = decoder->pc();

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

if (length > 0) {

if (tracer) {

tracer->Bytes(decoder->pc(), length);

tracer->Description(name);

tracer->Description(": ");

tracer->Description(reinterpret_cast<const char*>(decoder->pc()), length);

tracer->NextLine();

}

decoder->consume_bytes(length, name);

if (decoder->ok()) {

switch (grammar) {

case unibrow::Utf8Variant::kLossyUtf8:

break;

case unibrow::Utf8Variant::kUtf8:

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

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

}

break;

case unibrow::Utf8Variant::kWtf8:

if (!unibrow::Wtf8::ValidateEncoding(string_start, length)) {

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

}

break;

case unibrow::Utf8Variant::kUtf8NoTrap:

UNREACHABLE();

}

}

}

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

unibrow::Utf8Variant grammar,

const char* name) {

return consume_string(decoder, grammar, name, ITracer::NoTrace);

ITracer* tracer) {

WireBytesRef string = consume_utf8_string(decoder, "section name", tracer);

if (decoder->failed()) {

return kUnknownSectionCode;

}

const uint8_t* 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(kInstTraceString), kInstTraceSectionCode},

{base::StaticCharVector(kCompilationHintsString),

kCompilationHintsSectionCode},

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

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

{base::StaticCharVector(kExternalDebugInfoString),

kExternalDebugInfoSectionCode},

{base::StaticCharVector(kBuildIdString), kBuildIdSectionCode}};

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, ITracer* tracer)

: decoder_(decoder),

tracer_(tracer),

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 uint8_t* 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 uint8_t* payload_start() const { return payload_start_; }

uint32_t payload_length() const {

return static_cast<uint32_t>(section_end_ - payload_start_);

}

const uint8_t* 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_;

ITracer* tracer_;

SectionCode section_code_;

const uint8_t* section_start_;

const uint8_t* payload_start_;

const uint8_t* 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();

// Empty line before next section.

if (tracer_) tracer_->NextLine();

uint8_t section_code = decoder_->consume_u8("section kind", tracer_);

if (tracer_) {

tracer_->Description(": ");

tracer_->Description(SectionName(static_cast<SectionCode>(section_code)));

tracer_->NextLine();

}

// Read and check the section size.

uint32_t section_length = decoder_->consume_u32v("section length", tracer_);

if (tracer_) {

tracer_->Description(section_length);

tracer_->NextLine();

}

payload_start_ = decoder_->pc();

section_end_ = payload_start_ + section_length;

if (section_length > decoder_->available_bytes()) {

decoder_->errorf(

section_start_,

"section (code %u, \"%s\") extends past end of the module "

"(length %u, remaining bytes %u)",

section_code, SectionName(static_cast<SectionCode>(section_code)),

section_length, decoder_->available_bytes());

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 uint8_t* module_end = decoder_->end();

decoder_->set_end(section_end_);

section_code = IdentifyUnknownSectionInternal(decoder_, tracer_);

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_ = 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", tracer_);

}

}

bool ok) {

std::string path;

if (v8_flags.dump_wasm_module_path) {

path = v8_flags.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`.

// Limit the hash to 8 characters (32 bits).

uint32_t hash = static_cast<uint32_t>(GetWireBytesHash(module_bytes));

base::EmbeddedVector<char, 32> buf;

SNPrintF(buf, "%08x.%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;

}

public:

ModuleDecoderImpl(WasmEnabledFeatures enabled_features,

base::Vector<const uint8_t> wire_bytes, ModuleOrigin origin,

WasmDetectedFeatures* detected_features,

ITracer* tracer = ITracer::NoTrace)

: Decoder(wire_bytes),

enabled_features_(enabled_features),

detected_features_(detected_features),

module_(std::make_shared<WasmModule>(origin)),

module_start_(wire_bytes.begin()),

module_end_(wire_bytes.end()),

tracer_(tracer) {}

void onFirstError() override {

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

}

void DecodeModuleHeader(base::Vector<const uint8_t> bytes) {

if (failed()) return;

Reset(bytes);

const uint8_t* pos = pc_;

uint32_t magic_word = consume_u32("wasm magic", tracer_);

if (tracer_) tracer_->NextLine();

#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", tracer_);

if (tracer_) tracer_->NextLine();

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

// Check the order of ordered sections.

if (section_code >= kFirstSectionInModule &&

section_code < kFirstUnorderedSection) {

if (section_code < next_ordered_section_) {

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

return false;

}

next_ordered_section_ = section_code + 1;

return true;

}

// Ignore ordering problems in unknown / custom sections. Even allow them to

// appear multiple times. As optional sections we use them on a "best

// effort" basis.

if (section_code == kUnknownSectionCode) return true;

if (section_code > kLastKnownModuleSection) return true;

// The rest is standardized unordered sections; they are checked more

// thoroughly..

DCHECK_LE(kFirstUnorderedSection, section_code);

DCHECK_GE(kLastKnownModuleSection, section_code);

// Check that unordered sections don't appear multiple times.

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

// Define a helper to ensure that sections <= {before} appear before the

// current unordered section, and everything >= {after} appears after it.

auto check_order = [this, section_code](SectionCode before,

SectionCode after) -> bool {

DCHECK_LT(before, after);

if (next_ordered_section_ > after) {

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

SectionName(section_code), SectionName(after));

return false;

}

if (next_ordered_section_ <= before) next_ordered_section_ = before + 1;

return true;

};

// Now check the ordering constraints of specific unordered sections.

switch (section_code) {

case kDataCountSectionCode:

return check_order(kElementSectionCode, kCodeSectionCode);

case kTagSectionCode:

return check_order(kMemorySectionCode, kGlobalSectionCode);

case kStringRefSectionCode:

// TODO(12868): If there's a tag section, assert that we're after the

// tag section.

return check_order(kMemorySectionCode, kGlobalSectionCode);

case kInstTraceSectionCode:

// Custom section following code.metadata tool convention containing

// offsets specifying where trace marks should be emitted.

// Be lenient with placement of instruction trace section. All except

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

// ignored.

return true;

default:

return true;

}

}

void DecodeSection(SectionCode section_code,

base::Vector<const uint8_t> bytes, uint32_t offset) {

if (failed()) return;

Reset(bytes, offset);

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

TRACE("Decode Section %p - %p\n", bytes.begin(), bytes.end());

if (!CheckSectionOrder(section_code)) return;

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

break;

case kElementSectionCode:

DecodeElementSection();

break;

case kDataSectionCode:

DecodeDataSection();

break;

case kNameSectionCode:

DecodeNameSection();

break;

case kSourceMappingURLSectionCode:

DecodeSourceMappingURLSection();

break;

case kDebugInfoSectionCode:

module_->debug_symbols[WasmDebugSymbols::Type::EmbeddedDWARF] = {

WasmDebugSymbols::Type::EmbeddedDWARF, {}};

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

break;

case kExternalDebugInfoSectionCode:

DecodeExternalDebugInfoSection();

break;

case kBuildIdSectionCode:

DecodeBuildIdSection();

break;

case kInstTraceSectionCode:

if (enabled_features_.has_instruction_tracing()) {

DecodeInstTraceSection();

} else {

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

// custom section anyways.

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

}

break;

case kCompilationHintsSectionCode:

// TODO(jkummerow): We're missing tracing support for well-known

// custom sections. This confuses `wami --full-hexdump` e.g.

// for the modules created by

// mjsunit/wasm/compilation-hints-streaming-compilation.js.

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:

DecodeTagSection();

break;

case kStringRefSectionCode:

if (enabled_features_.has_stringref()) {

DecodeStringRefSection();

} else {

errorf(pc(),

"unexpected section <%s> (enable with "

"--experimental-wasm-stringref)",

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

}

}

static constexpr const char* TypeKindName(uint8_t kind) {

switch (kind) {

// clang-format off

case kWasmFunctionTypeCode: return "func";

case kWasmStructTypeCode: return "struct";

case kWasmArrayTypeCode: return "array";

case kWasmContTypeCode: return "cont";

default: return "unknown";

// clang-format on

}

}

TypeDefinition consume_base_type_definition(bool is_descriptor) {

const bool is_final = true;

const bool shared = false;

uint8_t kind = consume_u8(" kind", tracer_);

if (tracer_) {

tracer_->Description(": ");

tracer_->Description(TypeKindName(kind));

}

switch (kind) {

case kWasmFunctionTypeCode: {

const FunctionSig* sig = consume_sig(&module_->signature_zone);

if (sig == nullptr) {

CHECK(!ok());

return {};

}

return {sig, kNoSuperType, is_final, shared};

}

case kWasmStructTypeCode: {

module_->is_wasm_gc = true;

const StructType* type =

consume_struct(&module_->signature_zone, is_descriptor);

if (type == nullptr) {

CHECK(!ok());

return {};

}

return {type, kNoSuperType, is_final, shared};

}

case kWasmArrayTypeCode: {

module_->is_wasm_gc = true;

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

if (type == nullptr) {

CHECK(!ok());

return {};

}

return {type, kNoSuperType, is_final, shared};

}

case kWasmContTypeCode: {

if (!enabled_features_.has_wasmfx()) {

error(pc() - 1,

"core stack switching not enabled (enable with "

"--experimental-wasm-wasmfx)");

return {};

}

const uint8_t* pos = pc();

HeapType hp = consume_heap_type();

if (!hp.is_index()) {

error(pos, "cont type must refer to a signature index");

return {};

}

ContType* type = module_->signature_zone.New<ContType>(hp.ref_index());

return {type, kNoSuperType, is_final, shared};

}

default:

if (tracer_) tracer_->NextLine();

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

return {};

}

}

TypeDefinition consume_described_type(bool is_descriptor) {

uint8_t kind = read_u8<Decoder::FullValidationTag>(pc(), "type kind");

if (kind == kWasmDescriptorCode) {

if (!enabled_features_.has_custom_descriptors()) {

error(pc(),

"descriptor types need --experimental-wasm-custom-descriptors");

return {};

}

detected_features_->add_custom_descriptors();

consume_bytes(1, " described_by", tracer_);

const uint8_t* pos = pc();

uint32_t descriptor = consume_u32v("descriptor", tracer_);

if (descriptor >= module_->types.size()) {

errorf(pos, "descriptor type index %u is out of bounds", descriptor);

return {};

}

if (tracer_) tracer_->NextLine();

TypeDefinition type = consume_base_type_definition(is_descriptor);

if (type.kind != TypeDefinition::kStruct) {

error(pos - 1, "'descriptor' may only be used with structs");

return {};

}

type.descriptor = ModuleTypeIndex{descriptor};

return type;

} else {

return consume_base_type_definition(is_descriptor);

}

}

TypeDefinition consume_describing_type(size_t current_type_index) {

uint8_t kind = read_u8<Decoder::FullValidationTag>(pc(), "type kind");

if (kind == kWasmDescribesCode) {

if (!enabled_features_.has_custom_descriptors()) {

error(pc(),

"descriptor types need --experimental-wasm-custom-descriptors");

return {};

}

detected_features_->add_custom_descriptors();

consume_bytes(1, " describes", tracer_);

const uint8_t* pos = pc();

uint32_t describes = consume_u32v("describes", tracer_);

if (describes >= current_type_index) {

error(pos, "types can only describe previously-declared types");

return {};

}

if (tracer_) tracer_->NextLine();

TypeDefinition type = consume_described_type(true);

if (type.kind != TypeDefinition::kStruct) {

error(pos - 1, "'describes' may only be used with structs");

return {};

}

type.describes = ModuleTypeIndex{describes};

return type;

} else {

return consume_described_type(false);

}

}

TypeDefinition consume_shared_type(size_t current_type_index) {

uint8_t kind = read_u8<Decoder::FullValidationTag>(pc(), "type kind");

if (kind == kSharedFlagCode) {

if (!v8_flags.experimental_wasm_shared) {

errorf(pc() - 1,

"unknown type form: %d, enable with --experimental-wasm-shared",

kind);

return {};

}

module_->has_shared_part = true;

consume_bytes(1, " shared", tracer_);

TypeDefinition type = consume_describing_type(current_type_index);

if (type.kind == TypeDefinition::kFunction ||

type.kind == TypeDefinition::kCont) {

// TODO(42204563): Support shared functions/continuations.

error(pc() - 1, "shared functions/continuations are not supported yet");

return {};

}

type.is_shared = true;

return type;

} else {

return consume_describing_type(current_type_index);

}

}

// {current_type_index} is the index of the type that's being decoded.

// Any supertype must have a lower index.

TypeDefinition consume_subtype_definition(size_t current_type_index) {

uint8_t kind = read_u8<Decoder::FullValidationTag>(pc(), "type kind");

if (kind == kWasmSubtypeCode || kind == kWasmSubtypeFinalCode) {

module_->is_wasm_gc = true;

bool is_final = kind == kWasmSubtypeFinalCode;

consume_bytes(1, is_final ? " subtype final, " : " subtype extensible, ",

tracer_);

constexpr uint32_t kMaximumSupertypes = 1;

uint32_t supertype_count =

consume_count("supertype count", kMaximumSupertypes);

uint32_t supertype = kNoSuperType.index;

if (supertype_count == 1) {

supertype = consume_u32v("supertype", tracer_);

if (supertype >= current_type_index) {

errorf("type %u: invalid supertype %u", current_type_index,

supertype);

return {};

}

if (tracer_) {

tracer_->Description(supertype);

tracer_->NextLine();

}

}

TypeDefinition type = consume_shared_type(current_type_index);

type.supertype = ModuleTypeIndex{supertype};

type.is_final = is_final;

return type;

} else {

return consume_shared_type(current_type_index);

}

}

void DecodeTypeSection() {

TypeCanonicalizer* type_canon = GetTypeCanonicalizer();

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

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

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

uint8_t kind = read_u8<Decoder::FullValidationTag>(pc(), "type kind");

size_t initial_size = module_->types.size();

uint32_t group_size = 1;

if (kind == kWasmRecursiveTypeGroupCode) {

module_->is_wasm_gc = true;

uint32_t rec_group_offset = pc_offset();

consume_bytes(1, "rec. group definition", tracer_);

if (tracer_) tracer_->NextLine();

group_size = consume_count("recursive group size", kV8MaxWasmTypes);

if (tracer_) tracer_->RecGroupOffset(rec_group_offset, group_size);

}

if (initial_size + group_size > kV8MaxWasmTypes) {

errorf(pc(), "Type definition count exceeds maximum %zu",

kV8MaxWasmTypes);

return;

}

// We need to resize types before decoding the type definitions in this

// group, so that the correct type size is visible to type definitions.

module_->types.resize(initial_size + group_size);

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

if (tracer_) tracer_->TypeOffset(pc_offset());

TypeDefinition type = consume_subtype_definition(initial_size + j);

if (failed()) return;

module_->types[initial_size + j] = type;

}

FinalizeRecgroup(group_size, type_canon);

if (kind == kWasmRecursiveTypeGroupCode && tracer_) {

tracer_->Description("end of rec. group");

tracer_->NextLine();

}

}

}

void FinalizeRecgroup(uint32_t group_size, TypeCanonicalizer* type_canon) {

// Now that we have decoded the entire recgroup, check its validity,

// initialize additional data, and canonicalize it:

// - check supertype validity

// - propagate subtyping depths

// - validate is_shared bits and set up RefTypeKind fields

WasmModule* module = module_.get();

uint32_t end_index = static_cast<uint32_t>(module->types.size());

uint32_t start_index = end_index - group_size;

for (uint32_t i = start_index; ok() && i < end_index; ++i) {

TypeDefinition& type_def = module_->types[i];

bool is_shared = type_def.is_shared;

switch (type_def.kind) {

case TypeDefinition::kFunction: {

base::Vector<const ValueType> all = type_def.function_sig->all();

size_t count = all.size();

ValueType* storage = const_cast<ValueType*>(all.begin());

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

value_type_reader::Populate(&storage[j], module);

ValueType type = storage[j];

if (is_shared && !type.is_shared()) {

DCHECK(v8_flags.experimental_wasm_shared);

uint32_t retcount =

static_cast<uint32_t>(type_def.function_sig->return_count());

const char* param_or_return =

j < retcount ? "return" : "parameter";

uint32_t index = j < retcount ? j : j - retcount;

// {pc_} isn't very accurate, it's pointing at the end of the

// recgroup. So to ease debugging, we print the type's index.

errorf(pc_,

"Type %u: shared signature must have shared %s types, "

"actual type for %s %d is %s",

i, param_or_return, param_or_return, index,

type.name().c_str());

return;

}

}

break;

}

case TypeDefinition::kStruct: {

size_t count = type_def.struct_type->field_count();

ValueType* storage =

const_cast<ValueType*>(type_def.struct_type->fields().begin());

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

value_type_reader::Populate(&storage[j], module);

ValueType type = storage[j];

if (is_shared && !type.is_shared()) {

errorf(pc_,

"Type %u: shared struct must have shared field types, "

"actual type for field %d is %s",

i, j, type.name().c_str());

return;

}

}

if (type_def.descriptor.valid()) {

const TypeDefinition& descriptor =

module->type(type_def.descriptor);

if (descriptor.describes.index != i) {

uint32_t d = type_def.descriptor.index;

errorf(pc_,

"Type %u has descriptor %u but %u doesn't describe %u", i,

d, d, i);

return;

}

if (descriptor.is_shared != type_def.is_shared) {

errorf(pc_,

"Type %u and its descriptor %u must have same sharedness",

i, type_def.descriptor.index);

return;

}

}

if (type_def.describes.valid()) {

if (module->type(type_def.describes).descriptor.index != i) {

uint32_t d = type_def.describes.index;

errorf(pc_,

"Type %u describes %u but %u isn't a descriptor for %u", i,

d, d, i);

return;

}

}

break;

}

case TypeDefinition::kArray: {

value_type_reader::Populate(

const_cast<ArrayType*>(type_def.array_type)

->element_type_writable_ptr(),

module);

ValueType type = type_def.array_type->element_type();

if (is_shared && !type.is_shared()) {

errorf(pc_,

"Type %u: shared array must have shared element type, "

"actual element type is %s",

i, type.name().c_str());

return;

}

break;

}

case TypeDefinition::kCont: {

ModuleTypeIndex contfun_typeid =

type_def.cont_type->contfun_typeindex();

const TypeDefinition contfun_type =

module_->types[contfun_typeid.index];

if (contfun_type.kind != TypeDefinition::kFunction) {

errorf(pc_,

"Type %u: cont type must refer to a signature index, "

"actual type is %s",

i, module_->heap_type(contfun_typeid).name().c_str());

return;

}

if (is_shared && !contfun_type.is_shared) {

errorf(pc_,

"Type %u: shared cont type must refer to a shared signature,"

" actual type is %s",

module_->heap_type(contfun_typeid).name().c_str());

return;

}

break;

}

}

}

module->isorecursive_canonical_type_ids.resize(end_index);

type_canon->AddRecursiveGroup(module, group_size);

for (uint32_t i = start_index; ok() && i < end_index; ++i) {

TypeDefinition& type_def = module_->types[i];

ModuleTypeIndex explicit_super = type_def.supertype;

if (!explicit_super.valid()) continue; // No supertype.

DCHECK_LT(explicit_super.index, i); // Checked during decoding.

uint32_t depth = module->type(explicit_super).subtyping_depth + 1;

type_def.subtyping_depth = depth;

DCHECK_GE(depth, 0);

if (depth > kV8MaxRttSubtypingDepth) {

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

return;

}

// This check is technically redundant; we include for the improved error

// message.

if (module->type(explicit_super).is_final) {

errorf("type %u extends final type %u", i, explicit_super.index);

return;

}

if (!ValidSubtypeDefinition(ModuleTypeIndex{i}, explicit_super, module,

module)) {

errorf("type %u has invalid explicit supertype %u", i,

explicit_super.index);

return;

}

}

}

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

if (tracer_) tracer_->ImportOffset(pc_offset());

const uint8_t* pos = pc_;

WireBytesRef module_name =

consume_utf8_string(this, "module name", tracer_);

WireBytesRef field_name =

consume_utf8_string(this, "field name", tracer_);

ImportExportKindCode kind =

static_cast<ImportExportKindCode>(consume_u8("kind", tracer_));

if (tracer_) {

tracer_->Description(": ");

tracer_->Description(ExternalKindName(kind));

}

module_->import_table.push_back(WasmImport{

.module_name = module_name, .field_name = field_name, .kind = kind});

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

switch (kind) {

case kExternalFunction: {

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

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

module_->num_imported_functions++;

module_->functions.push_back(WasmFunction{

.func_index = import->index,

.imported = true,

});

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

function->sig_index =

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

break;

}

case kExternalTable: {

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

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

const uint8_t* type_position = pc();

ValueType type = consume_value_type(module_.get());

if (!type.is_object_reference()) {

errorf(type_position, "Invalid table type %s", type.name().c_str());

break;

}

module_->num_imported_tables++;

module_->tables.push_back(WasmTable{

.type = type,

.imported = true,

});

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

consume_table_flags(table);

DCHECK_IMPLIES(table->shared,

v8_flags.experimental_wasm_shared || !ok());

if (table->shared && v8_flags.experimental_wasm_shared) {

module_->has_shared_part = true;

if (!IsShared(type, module_.get())) {

errorf(type_position,

"Shared table %i must have shared element type, actual "

"type %s",

i, type.name().c_str());

break;

}

}

// Note that we should not throw an error if the declared maximum size

// is oob. We will instead fail when growing at runtime.

uint64_t kNoMaximum = kMaxUInt64;

consume_resizable_limits(

"table", "elements", wasm::max_table_size(), &table->initial_size,

table->has_maximum_size, kNoMaximum, &table->maximum_size,

table->is_table64() ? k64BitLimits : k32BitLimits);

break;

}

case kExternalMemory: {