[wasm] Break loops in the module-decoder upon error.

src/wasm/module-decoder.cc

 // 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/macro-assembler.h"
 #include "src/objects.h"
@@ skipping 133 matching lines @@
         case WasmSection::Code::Memory: {
           module->min_mem_pages = consume_u32v("min memory");
           module->max_mem_pages = consume_u32v("max memory");
           module->mem_export = consume_u8("export memory") != 0;
           break;
         }
         case WasmSection::Code::Signatures: {
           uint32_t signatures_count = consume_u32v("signatures count");
           module->signatures.reserve(SafeReserve(signatures_count));
           // Decode signatures.
-          for (uint32_t i = 0; i < signatures_count; ++i) {
-            if (failed()) break;
+          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->signatures.push_back(s);
           }
           break;
         }
         case WasmSection::Code::FunctionSignatures: {
           uint32_t functions_count = consume_u32v("functions count");
           module->functions.reserve(SafeReserve(functions_count));
-          for (uint32_t i = 0; i < functions_count; ++i) {
-            if (failed()) break;
+          for (uint32_t i = 0; ok() && i < functions_count; ++i) {
             module->functions.push_back({nullptr,  // sig
                                          i,        // func_index
                                          0,        // sig_index
                                          0,        // name_offset
                                          0,        // name_length
                                          0,        // code_start_offset
                                          0});      // code_end_offset
             WasmFunction* function = &module->functions.back();
             function->sig_index = consume_sig_index(module, &function->sig);
           }
           break;
         }
         case WasmSection::Code::FunctionBodies: {
           const byte* pos = pc_;
           uint32_t functions_count = consume_u32v("functions count");
           if (functions_count != module->functions.size()) {
             error(pos, pos, "function body count %u mismatch (%u expected)",
                   functions_count,
                   static_cast<uint32_t>(module->functions.size()));
             break;
           }
-          for (uint32_t i = 0; i < functions_count; ++i) {
+          for (uint32_t i = 0; ok() && i < functions_count; ++i) {
             WasmFunction* function = &module->functions[i];
             uint32_t size = consume_u32v("body size");
             function->code_start_offset = pc_offset();
             function->code_end_offset = pc_offset() + size;
 
             TRACE("  +%d  %-20s: (%d bytes)\n", pc_offset(), "function body",
                   size);
             pc_ += size;
             if (pc_ > limit_) {
               error(pc_, "function body extends beyond end of file");
             }
           }
           break;
         }
         case WasmSection::Code::Names: {
           const byte* pos = pc_;
           uint32_t functions_count = consume_u32v("functions count");
           if (functions_count != module->functions.size()) {
             error(pos, pos, "function name count %u mismatch (%u expected)",
                   functions_count,
                   static_cast<uint32_t>(module->functions.size()));
             break;
           }
 
-          for (uint32_t i = 0; i < functions_count; ++i) {
+          for (uint32_t i = 0; ok() && i < functions_count; ++i) {
             WasmFunction* function = &module->functions[i];
             function->name_offset =
                 consume_string(&function->name_length, false);
 
             uint32_t local_names_count = consume_u32v("local names count");
-            for (uint32_t j = 0; j < local_names_count; j++) {
+            for (uint32_t j = 0; ok() && j < local_names_count; j++) {
               uint32_t unused = 0;
               uint32_t offset = consume_string(&unused, false);
               USE(unused);
               USE(offset);
             }
           }
           break;
         }
         case WasmSection::Code::Globals: {
           uint32_t globals_count = consume_u32v("globals count");
           module->globals.reserve(SafeReserve(globals_count));
           // Decode globals.
-          for (uint32_t i = 0; i < globals_count; ++i) {
-            if (failed()) break;
+          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({0, 0, kAstStmt, 0, false});
             WasmGlobal* global = &module->globals.back();
             DecodeGlobalInModule(global);
           }
           break;
         }
         case WasmSection::Code::DataSegments: {
           uint32_t data_segments_count = consume_u32v("data segments count");
           module->data_segments.reserve(SafeReserve(data_segments_count));
           // Decode data segments.
-          for (uint32_t i = 0; i < data_segments_count; ++i) {
-            if (failed()) break;
+          for (uint32_t i = 0; ok() && i < data_segments_count; ++i) {
             TRACE("DecodeDataSegment[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
             module->data_segments.push_back({0,        // dest_addr
                                              0,        // source_offset
                                              0,        // source_size
                                              false});  // init
             WasmDataSegment* segment = &module->data_segments.back();
             DecodeDataSegmentInModule(module, segment);
           }
           break;
         }
         case WasmSection::Code::FunctionTable: {
           // An indirect function table requires functions first.
           CheckForFunctions(module, section);
           // Assume only one table for now.
           static const uint32_t kSupportedTableCount = 1;
           module->function_tables.reserve(SafeReserve(kSupportedTableCount));
           // Decode function table.
-          for (uint32_t i = 0; i < kSupportedTableCount; ++i) {
-            if (failed()) break;
+          for (uint32_t i = 0; ok() && i < kSupportedTableCount; ++i) {
             TRACE("DecodeFunctionTable[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
             module->function_tables.push_back({0, 0, std::vector<uint16_t>()});
             DecodeFunctionTableInModule(module, &module->function_tables[i]);
           }
           break;
         }
         case WasmSection::Code::StartFunction: {
           // Declares a start function for a module.
           CheckForFunctions(module, section);
           if (module->start_function_index >= 0) {
             error("start function already declared");
             break;
           }
           WasmFunction* func;
           const byte* pos = pc_;
           module->start_function_index = consume_func_index(module, &func);
           if (func && func->sig->parameter_count() > 0) {
             error(pos, "invalid start function: non-zero parameter count");
             break;
           }
           break;
         }
         case WasmSection::Code::ImportTable: {
           uint32_t import_table_count = consume_u32v("import table count");
           module->import_table.reserve(SafeReserve(import_table_count));
           // Decode import table.
-          for (uint32_t i = 0; i < import_table_count; ++i) {
-            if (failed()) break;
+          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({nullptr,  // sig
                                             0,        // sig_index
                                             0,        // module_name_offset
                                             0,        // module_name_length
                                             0,        // function_name_offset
                                             0});      // function_name_length
             WasmImport* import = &module->import_table.back();
 
             import->sig_index = consume_sig_index(module, &import->sig);
             const byte* pos = pc_;
             import->module_name_offset =
                 consume_string(&import->module_name_length, true);
             if (import->module_name_length == 0) {
               error(pos, "import module name cannot be NULL");
             }
             import->function_name_offset =
                 consume_string(&import->function_name_length, true);
           }
           break;
         }
         case WasmSection::Code::ExportTable: {
           // Declares an export table.
           CheckForFunctions(module, section);
           uint32_t export_table_count = consume_u32v("export table count");
           module->export_table.reserve(SafeReserve(export_table_count));
           // Decode export table.
-          for (uint32_t i = 0; i < export_table_count; ++i) {
-            if (failed()) break;
+          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,    // func_index
                                             0,    // name_offset
                                             0});  // name_length
             WasmExport* exp = &module->export_table.back();
 
             WasmFunction* func;
             exp->func_index = consume_func_index(module, &func);
@@ skipping 171 matching lines @@
   // Decodes a single function table inside a module starting at {pc_}.
   void DecodeFunctionTableInModule(WasmModule* module,
                                    WasmIndirectFunctionTable* table) {
     table->size = consume_u32v("function table entry count");
     table->max_size = table->size;
 
     if (table->max_size != table->size) {
       error("invalid table maximum size");
     }
 
-    for (uint32_t i = 0; i < table->size; ++i) {
+    for (uint32_t i = 0; ok() && i < table->size; ++i) {
       uint16_t index = consume_u32v();
       if (index >= module->functions.size()) {
         error(pc_ - sizeof(index), "invalid function index");
         break;
       }
       table->values.push_back(index);
     }
   }
 
   // Calculate individual global offsets and total size of globals table.
@@ skipping 289 matching lines @@
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8