Lines Matching defs:validate
45 // Return the evaluation of `condition` if validate==true, DCHECK that it's
48 (validate ? V8_LIKELY(condition) : [&] { \
134 template <Decoder::ValidateFlag validate, typename... Args>
137 CHECK(validate == Decoder::kFullValidation ||
138 validate == Decoder::kBooleanValidation);
140 if (validate == Decoder::kBooleanValidation) {
148 template <Decoder::ValidateFlag validate>
150 CHECK(validate == Decoder::kFullValidation ||
151 validate == Decoder::kBooleanValidation);
152 if (validate == Decoder::kBooleanValidation) {
160 template <Decoder::ValidateFlag validate, typename... Args>
162 CHECK(validate == Decoder::kFullValidation ||
163 validate == Decoder::kBooleanValidation);
165 if (validate == Decoder::kBooleanValidation) {
173 template <Decoder::ValidateFlag validate>
175 CHECK(validate == Decoder::kFullValidation ||
176 validate == Decoder::kBooleanValidation);
177 if (validate == Decoder::kBooleanValidation) {
188 template <Decoder::ValidateFlag validate>
192 int64_t heap_index = decoder->read_i33v<validate>(pc, length, "heap type");
196 DecodeError<validate>(decoder, pc, "Unknown heap type %" PRId64,
209 DecodeError<validate>(
220 DecodeError<validate>(decoder, pc, "Unknown heap type %" PRId64,
226 DecodeError<validate>(decoder, pc,
233 DecodeError<validate>(
242 DecodeError<validate>(decoder, pc, "Type index %u is out of bounds",
256 // Registers an error for an invalid type only if {validate} is not
258 template <Decoder::ValidateFlag validate>
263 byte val = decoder->read_u8<validate>(pc, "value type opcode");
276 DecodeError<validate>(
304 DecodeError<validate>(decoder, pc,
311 read_heap_type<validate>(decoder, pc + 1, length, module, enabled);
321 DecodeError<validate>(
327 uint32_t depth = decoder->read_u32v<validate>(pc + 1, length, "depth");
330 DecodeError<validate>(
340 decoder->read_u32v<validate>(pc + *length, &type_index_length);
343 DecodeError<validate>(
353 DecodeError<validate>(decoder, pc, "Type index %u is out of bounds",
361 DecodeError<validate>(
367 DecodeError<validate>(decoder, pc, "Wasm SIMD unsupported");
378 if (validate) {
379 DecodeError<validate>(decoder, pc, "invalid value type 0x%x", code);
384 if (validate) {
385 DecodeError<validate>(decoder, pc, "invalid value type 0x%x", code);
394 template <Decoder::ValidateFlag validate>
399 value = decoder->read_i32v<validate>(pc, &length, "immi32");
403 template <Decoder::ValidateFlag validate>
408 value = decoder->read_i64v<validate>(pc, &length, "immi64");
412 template <Decoder::ValidateFlag validate>
420 uint32_t tmp = decoder->read_u32<validate>(pc, "immf32");
425 template <Decoder::ValidateFlag validate>
431 uint64_t tmp = decoder->read_u64<validate>(pc, "immf64");
437 template <Decoder::ValidateFlag validate>
442 index = decoder->read_u8<validate>(pc, "memory index");
448 template <Decoder::ValidateFlag validate>
454 index = decoder->read_u32v<validate>(pc, &length, name);
458 template <Decoder::ValidateFlag validate>
459 struct TagIndexImmediate : public IndexImmediate<validate> {
463 : IndexImmediate<validate>(decoder, pc, "tag index") {}
466 template <Decoder::ValidateFlag validate>
467 struct GlobalIndexImmediate : public IndexImmediate<validate> {
471 : IndexImmediate<validate>(decoder, pc, "global index") {}
474 template <Decoder::ValidateFlag validate>
475 struct StructIndexImmediate : public IndexImmediate<validate> {
479 : IndexImmediate<validate>(decoder, pc, "struct index") {}
482 template <Decoder::ValidateFlag validate>
483 struct ArrayIndexImmediate : public IndexImmediate<validate> {
487 : IndexImmediate<validate>(decoder, pc, "array index") {}
489 template <Decoder::ValidateFlag validate>
490 struct CallFunctionImmediate : public IndexImmediate<validate> {
494 : IndexImmediate<validate>(decoder, pc, "function index") {}
497 template <Decoder::ValidateFlag validate>
505 decoder->read_u32v<validate>(pc, &length, "number of select types");
507 DecodeError<validate>(
513 type = value_type_reader::read_value_type<validate>(
519 template <Decoder::ValidateFlag validate>
529 decoder->read_i33v<validate>(pc, &length, "block type");
535 DecodeError<validate>(decoder, pc, "invalid block type %" PRId64,
540 type = value_type_reader::read_value_type<validate>(decoder, pc, &length,
569 template <Decoder::ValidateFlag validate>
574 depth = decoder->read_u32v<validate>(pc, &length, "branch depth");
578 template <Decoder::ValidateFlag validate>
580 StructIndexImmediate<validate> struct_imm;
581 IndexImmediate<validate> field_imm;
589 template <Decoder::ValidateFlag validate>
591 IndexImmediate<validate> sig_imm;
592 IndexImmediate<validate> table_imm;
601 template <Decoder::ValidateFlag validate>
609 table_count = decoder->read_u32v<validate>(pc, &len, "table count");
615 template <Decoder::ValidateFlag validate>
625 decoder_->read_u32v<validate>(pc_, &length, "branch table entry");
638 const BranchTableImmediate<validate>& imm)
652 template <Decoder::ValidateFlag validate,
656 template <Decoder::ValidateFlag validate>
665 decoder->read_u32v<validate>(pc, &alignment_length, "alignment");
667 DecodeError<validate>(
674 offset = is_memory64 ? decoder->read_u64v<validate>(
676 : decoder->read_u32v<validate>(
683 template <Decoder::ValidateFlag validate>
689 lane = decoder->read_u8<validate>(pc, "lane");
694 template <Decoder::ValidateFlag validate>
700 value[i] = decoder->read_u8<validate>(pc + i, "value");
705 template <Decoder::ValidateFlag validate>
707 IndexImmediate<validate> data_segment;
708 MemoryIndexImmediate<validate> memory;
717 template <Decoder::ValidateFlag validate>
719 MemoryIndexImmediate<validate> memory_src;
720 MemoryIndexImmediate<validate> memory_dst;
729 template <Decoder::ValidateFlag validate>
731 IndexImmediate<validate> element_segment;
732 IndexImmediate<validate> table;
741 template <Decoder::ValidateFlag validate>
743 IndexImmediate<validate> table_dst;
744 IndexImmediate<validate> table_src;
753 template <Decoder::ValidateFlag validate>
759 : type(value_type_reader::read_heap_type<validate>(decoder, pc, &length,
763 template <Decoder::ValidateFlag validate>
780 template <Decoder::ValidateFlag validate>
781 struct ValueBase : public PcForErrors<validate> {
785 : PcForErrors<validate>(pc), type(type) {}
829 template <typename Value, Decoder::ValidateFlag validate>
830 struct ControlBase : public PcForErrors<validate> {
849 : PcForErrors<validate>(pc),
912 F(S128Const, Simd128Immediate<validate>& imm, Value* result) \
917 F(GlobalGet, Value* result, const GlobalIndexImmediate<validate>& imm) \
918 F(StructNewWithRtt, const StructIndexImmediate<validate>& imm, \
920 F(StructNewDefault, const StructIndexImmediate<validate>& imm, \
922 F(ArrayInit, const ArrayIndexImmediate<validate>& imm, \
924 F(ArrayInitFromData, const ArrayIndexImmediate<validate>& array_imm, \
925 const IndexImmediate<validate>& data_segment, const Value& offset, \
942 F(LocalGet, Value* result, const IndexImmediate<validate>& imm) \
943 F(LocalSet, const Value& value, const IndexImmediate<validate>& imm) \
945 const IndexImmediate<validate>& imm) \
948 F(GlobalSet, const Value& value, const GlobalIndexImmediate<validate>& imm) \
950 const IndexImmediate<validate>& imm) \
952 const IndexImmediate<validate>& imm) \
959 F(BrTable, const BranchTableImmediate<validate>& imm, const Value& key) \
961 F(LoadMem, LoadType type, const MemoryAccessImmediate<validate>& imm, \
964 const MemoryAccessImmediate<validate>& imm, const Value& index, \
967 const MemoryAccessImmediate<validate>& imm, const uint8_t laneidx, \
969 F(StoreMem, StoreType type, const MemoryAccessImmediate<validate>& imm, \
971 F(StoreLane, StoreType type, const MemoryAccessImmediate<validate>& imm, \
975 F(CallDirect, const CallFunctionImmediate<validate>& imm, \
978 const CallIndirectImmediate<validate>& imm, const Value args[], \
984 F(ReturnCall, const CallFunctionImmediate<validate>& imm, \
987 const CallIndirectImmediate<validate>& imm, const Value args[]) \
992 F(SimdLaneOp, WasmOpcode opcode, const SimdLaneImmediate<validate>& imm, \
994 F(S128Const, const Simd128Immediate<validate>& imm, Value* result) \
995 F(Simd8x16ShuffleOp, const Simd128Immediate<validate>& imm, \
997 F(Throw, const TagIndexImmediate<validate>& imm, \
1000 F(CatchException, const TagIndexImmediate<validate>& imm, Control* block, \
1005 const MemoryAccessImmediate<validate>& imm, Value* result) \
1007 F(MemoryInit, const MemoryInitImmediate<validate>& imm, const Value& dst, \
1009 F(DataDrop, const IndexImmediate<validate>& imm) \
1010 F(MemoryCopy, const MemoryCopyImmediate<validate>& imm, const Value& dst, \
1012 F(MemoryFill, const MemoryIndexImmediate<validate>& imm, const Value& dst, \
1014 F(TableInit, const TableInitImmediate<validate>& imm, \
1016 F(ElemDrop, const IndexImmediate<validate>& imm) \
1017 F(TableCopy, const TableCopyImmediate<validate>& imm, \
1019 F(TableGrow, const IndexImmediate<validate>& imm, const Value& value, \
1021 F(TableSize, const IndexImmediate<validate>& imm, Value* result) \
1022 F(TableFill, const IndexImmediate<validate>& imm, const Value& start, \
1025 const FieldImmediate<validate>& field, bool is_signed, Value* result) \
1027 const FieldImmediate<validate>& field, const Value& field_value) \
1028 F(ArrayNewWithRtt, const ArrayIndexImmediate<validate>& imm, \
1031 F(ArrayNewDefault, const ArrayIndexImmediate<validate>& imm, \
1034 const ArrayIndexImmediate<validate>& imm, const Value& index, \
1037 const ArrayIndexImmediate<validate>& imm, const Value& index, \
1075 template <Decoder::ValidateFlag validate, DecodingMode decoding_mode>
1123 uint32_t entries = read_u32v<validate>(pc, &length, "local decls count");
1139 read_u32v<validate>(pc + *total_length, &length, "local count");
1151 ValueType type = value_type_reader::read_value_type<validate>(
1170 // {validate} flag.
1173 wasm::DecodeError<validate>(this, std::forward<Args>(args)...);
1209 BlockTypeImmediate<validate> imm(WasmFeatures::All(), decoder, pc + 1,
1219 IndexImmediate<validate> imm(decoder, pc + 1, "local index");
1246 bool Validate(const byte* pc, TagIndexImmediate<validate>& imm) {
1255 bool Validate(const byte* pc, GlobalIndexImmediate<validate>& imm) {
1282 bool Validate(const byte* pc, StructIndexImmediate<validate>& imm) {
1291 bool Validate(const byte* pc, FieldImmediate<validate>& imm) {
1302 bool Validate(const byte* pc, ArrayIndexImmediate<validate>& imm) {
1320 bool Validate(const byte* pc, CallFunctionImmediate<validate>& imm) {
1329 bool Validate(const byte* pc, CallIndirectImmediate<validate>& imm) {
1357 bool Validate(const byte* pc, BranchDepthImmediate<validate>& imm,
1366 bool Validate(const byte* pc, BranchTableImmediate<validate>& imm,
1377 SimdLaneImmediate<validate>& imm) {
1422 bool Validate(const byte* pc, Simd128Immediate<validate>& imm) {
1435 bool Validate(const byte* pc, BlockTypeImmediate<validate>& imm) {
1446 bool Validate(const byte* pc, MemoryIndexImmediate<validate>& imm) {
1458 bool Validate(const byte* pc, MemoryAccessImmediate<validate>& imm) {
1466 bool Validate(const byte* pc, MemoryInitImmediate<validate>& imm) {
1471 bool Validate(const byte* pc, MemoryCopyImmediate<validate>& imm) {
1476 bool Validate(const byte* pc, TableInitImmediate<validate>& imm) {
1492 bool Validate(const byte* pc, TableCopyImmediate<validate>& imm) {
1505 // The following Validate* functions all validate an IndexImmediate, albeit
1507 bool ValidateTable(const byte* pc, IndexImmediate<validate>& imm) {
1518 bool ValidateElementSegment(const byte* pc, IndexImmediate<validate>& imm) {
1526 bool ValidateLocal(const byte* pc, IndexImmediate<validate>& imm) {
1534 bool ValidateType(const byte* pc, IndexImmediate<validate>& imm) {
1542 bool ValidateSignature(const byte* pc, IndexImmediate<validate>& imm) {
1550 bool ValidateFunction(const byte* pc, IndexImmediate<validate>& imm) {
1563 bool ValidateDataSegment(const byte* pc, IndexImmediate<validate>& imm) {
1592 BlockTypeImmediate<validate> imm(WasmFeatures::All(), decoder, pc + 1,
1602 BranchDepthImmediate<validate> imm(decoder, pc + 1);
1606 BranchTableImmediate<validate> imm(decoder, pc + 1);
1607 BranchTableIterator<validate> iterator(decoder, imm);
1612 TagIndexImmediate<validate> imm(decoder, pc + 1);
1616 BlockTypeImmediate<validate> imm(WasmFeatures::All(), decoder, pc + 1,
1627 CallFunctionImmediate<validate> imm(decoder, pc + 1);
1632 CallIndirectImmediate<validate> imm(decoder, pc + 1);
1642 SelectTypeImmediate<validate> imm(WasmFeatures::All(), decoder, pc + 1,
1650 IndexImmediate<validate> imm(decoder, pc + 1, "local index");
1655 GlobalIndexImmediate<validate> imm(decoder, pc + 1);
1660 IndexImmediate<validate> imm(decoder, pc + 1, "table index");
1664 ImmI32Immediate<validate> imm(decoder, pc + 1);
1668 ImmI64Immediate<validate> imm(decoder, pc + 1);
1676 HeapTypeImmediate<validate> imm(WasmFeatures::All(), decoder, pc + 1,
1684 IndexImmediate<validate> imm(decoder, pc + 1, "function index");
1698 MemoryAccessImmediate<validate> imm(decoder, pc + 1, UINT32_MAX,
1705 MemoryIndexImmediate<validate> imm(decoder, pc + 1);
1712 opcode = decoder->read_prefixed_opcode<validate>(pc, &length);
1724 MemoryInitImmediate<validate> imm(decoder, pc + length);
1728 IndexImmediate<validate> imm(decoder, pc + length,
1733 MemoryCopyImmediate<validate> imm(decoder, pc + length);
1737 MemoryIndexImmediate<validate> imm(decoder, pc + length);
1741 TableInitImmediate<validate> imm(decoder, pc + length);
1745 IndexImmediate<validate> imm(decoder, pc + length,
1750 TableCopyImmediate<validate> imm(decoder, pc + length);
1756 IndexImmediate<validate> imm(decoder, pc + length, "table index");
1760 if (validate) {
1768 opcode = decoder->read_prefixed_opcode<validate>(pc, &length);
1776 MemoryAccessImmediate<validate> imm(decoder, pc + length,
1782 MemoryAccessImmediate<validate> imm(
1794 if (validate) {
1802 opcode = decoder->read_prefixed_opcode<validate>(pc, &length,
1806 MemoryAccessImmediate<validate> imm(decoder, pc + length,
1815 if (validate) {
1824 decoder->read_prefixed_opcode<validate>(pc, &length, "gc_index");
1830 StructIndexImmediate<validate> imm(decoder, pc + length);
1837 FieldImmediate<validate> imm(decoder, pc + length);
1849 ArrayIndexImmediate<validate> imm(decoder, pc + length);
1854 ArrayIndexImmediate<validate> array_imm(decoder, pc + length);
1855 IndexImmediate<validate> length_imm(
1860 ArrayIndexImmediate<validate> dst_imm(decoder, pc + length);
1861 ArrayIndexImmediate<validate> src_imm(decoder,
1867 ArrayIndexImmediate<validate> array_imm(decoder, pc + length);
1868 IndexImmediate<validate> data_imm(
1877 BranchDepthImmediate<validate> imm(decoder, pc + length);
1885 IndexImmediate<validate> imm(decoder, pc + length, "type index");
1902 if (validate) {
1926 if (validate) {
1976 CallFunctionImmediate<validate> imm(this, pc + 1);
1981 CallIndirectImmediate<validate> imm(this, pc + 1);
1988 TagIndexImmediate<validate> imm(this, pc + 1);
2016 opcode = this->read_prefixed_opcode<validate>(pc);
2042 opcode = this->read_prefixed_opcode<validate>(pc);
2082 StructIndexImmediate<validate> imm(this, pc + 2);
2087 StructIndexImmediate<validate> imm(this, pc + 2);
2093 ArrayIndexImmediate<validate> array_imm(this, pc + 2);
2094 IndexImmediate<validate> length_imm(this, pc + 2 + array_imm.length,
2206 template <Decoder::ValidateFlag validate, typename Interface,
2208 class WasmFullDecoder : public WasmDecoder<validate, decoding_mode> {
2223 : WasmDecoder<validate, decoding_mode>(zone, module, enabled, detected,
2444 MemoryAccessImmediate<validate> MakeMemoryAccessImmediate(
2446 return MemoryAccessImmediate<validate>(
2580 BlockTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
2594 BranchDepthImmediate<validate> imm(this, this->pc_ + 1);
2608 TagIndexImmediate<validate> imm(this, this->pc_ + 1);
2619 BlockTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
2635 TagIndexImmediate<validate> imm(this, this->pc_ + 1);
2666 BranchDepthImmediate<validate> imm(this, this->pc_ + 1);
2714 BranchDepthImmediate<validate> imm(this, this->pc_ + 1);
2752 BranchDepthImmediate<validate> imm(this, this->pc_ + 1);
2797 BlockTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
2824 BlockTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
2837 BlockTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
2948 SelectTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
2962 BranchDepthImmediate<validate> imm(this, this->pc_ + 1);
2975 BranchDepthImmediate<validate> imm(this, this->pc_ + 1);
2989 BranchTableImmediate<validate> imm(this, this->pc_ + 1);
2990 BranchTableIterator<validate> iterator(this, imm);
3013 if (validate) {
3049 ImmI32Immediate<validate> imm(this, this->pc_ + 1);
3057 ImmI64Immediate<validate> imm(this, this->pc_ + 1);
3065 ImmF32Immediate<validate> imm(this, this->pc_ + 1);
3073 ImmF64Immediate<validate> imm(this, this->pc_ + 1);
3082 HeapTypeImmediate<validate> imm(this->enabled_, this, this->pc_ + 1,
3113 if (validate) {
3123 IndexImmediate<validate> imm(this, this->pc_ + 1, "function index");
3152 if (validate) {
3160 IndexImmediate<validate> imm(this, this->pc_ + 1, "local index");
3175 IndexImmediate<validate> imm(this, this->pc_ + 1, "local index");
3185 IndexImmediate<validate> imm(this, this->pc_ + 1, "local index");
3205 GlobalIndexImmediate<validate> imm(this, this->pc_ + 1);
3214 GlobalIndexImmediate<validate> imm(this, this->pc_ + 1);
3228 IndexImmediate<validate> imm(this, this->pc_ + 1, "table index");
3240 IndexImmediate<validate> imm(this, this->pc_ + 1, "table index");
3284 MemoryIndexImmediate<validate> imm(this, this->pc_ + 1);
3298 MemoryIndexImmediate<validate> imm(this, this->pc_ + 1);
3308 CallFunctionImmediate<validate> imm(this, this->pc_ + 1);
3320 CallIndirectImmediate<validate> imm(this, this->pc_ + 1);
3336 CallFunctionImmediate<validate> imm(this, this->pc_ + 1);
3352 CallIndirectImmediate<validate> imm(this, this->pc_ + 1);
3421 WasmOpcode full_opcode = this->template read_prefixed_opcode<validate>(
3441 WasmOpcode full_opcode = this->template read_prefixed_opcode<validate>(
3454 WasmOpcode full_opcode = this->template read_prefixed_opcode<validate>(
3463 WasmOpcode full_opcode = this->template read_prefixed_opcode<validate>(
3617 void SetBlockType(Control* c, BlockTypeImmediate<validate>& imm,
3762 MemoryAccessImmediate<validate> imm =
3779 MemoryAccessImmediate<validate> imm =
3793 MemoryAccessImmediate<validate> mem_imm =
3796 SimdLaneImmediate<validate> lane_imm(
3812 MemoryAccessImmediate<validate> mem_imm =
3815 SimdLaneImmediate<validate> lane_imm(
3828 MemoryAccessImmediate<validate> imm =
3840 Simd128Immediate<validate> imm(this, this->pc_ + opcode_length);
3849 SimdLaneImmediate<validate> imm(this, this->pc_ + opcode_length);
3863 SimdLaneImmediate<validate> imm(this, this->pc_ + opcode_length);
3876 Simd128Immediate<validate> imm(this, this->pc_ + opcode_length);
4056 StructIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4077 StructIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4079 if (validate) {
4106 FieldImmediate<validate> field(this, this->pc_ + opcode_length);
4130 FieldImmediate<validate> field(this, this->pc_ + opcode_length);
4153 FieldImmediate<validate> field(this, this->pc_ + opcode_length);
4173 ArrayIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4195 ArrayIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4221 ArrayIndexImmediate<validate> array_imm(this,
4242 IndexImmediate<validate> data_segment(this, data_index_pc,
4270 ArrayIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4291 ArrayIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4311 ArrayIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4330 ArrayIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
4341 ArrayIndexImmediate<validate> dst_imm(this, this->pc_ + opcode_length);
4349 ArrayIndexImmediate<validate> src_imm(
4376 ArrayIndexImmediate<validate> array_imm(this,
4379 IndexImmediate<validate> length_imm(
4437 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
4451 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
4507 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
4570 BranchDepthImmediate<validate> branch_depth(this,
4579 IndexImmediate<validate> imm(this, this->pc_ + pc_offset,
4655 BranchDepthImmediate<validate> branch_depth(this,
4664 IndexImmediate<validate> imm(this, this->pc_ + pc_offset,
4818 BranchDepthImmediate<validate> branch_depth(this,
4875 BranchDepthImmediate<validate> branch_depth(this,
4955 this->template read_u8<validate>(this->pc_ + opcode_length, "zero");
4969 MemoryAccessImmediate<validate> imm = MakeMemoryAccessImmediate(
5006 MemoryInitImmediate<validate> imm(this, this->pc_ + opcode_length);
5017 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
5026 MemoryCopyImmediate<validate> imm(this, this->pc_ + opcode_length);
5037 MemoryIndexImmediate<validate> imm(this, this->pc_ + opcode_length);
5048 TableInitImmediate<validate> imm(this, this->pc_ + opcode_length);
5057 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
5066 TableCopyImmediate<validate> imm(this, this->pc_ + opcode_length);
5075 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
5088 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
5097 IndexImmediate<validate> imm(this, this->pc_ + opcode_length,
5278 static_assert(validate, "Call this function only within VALIDATE");
5366 static_assert(validate, "Call this function only within VALIDATE");
5386 static_assert(validate, "Call this function only within VALIDATE");
5403 static_assert(validate, "Call this function only within VALIDATE");
5475 static constexpr Decoder::ValidateFlag validate = Decoder::kFullValidation;
5477 using Value = ValueBase<validate>;
5478 using Control = ControlBase<Value, validate>;
5479 using FullDecoder = WasmFullDecoder<validate, EmptyInterface>;