[Wasm] Convert many of the fixed-size values to LEB128.

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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/wasm/decoder.h"
 #include "src/wasm/module-decoder.h"
@@ skipping 177 matching lines @@
           CheckForPreviousSection(sections, kDeclFunctions, true);
           int length;
           uint32_t function_table_count =
               consume_u32v(&length, "function table count");
           module->function_table.reserve(SafeReserve(function_table_count));
           // Decode function table.
           for (uint32_t i = 0; i < function_table_count; i++) {
             if (failed()) break;
             TRACE("DecodeFunctionTable[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
-            uint16_t index = consume_u16();
+            uint16_t index = consume_u32v(&length);
             if (index >= module->functions.size()) {
               error(pc_ - 2, "invalid function index");
               break;
             }
             module->function_table.push_back(index);
           }
           break;
         }
         case kDeclStartFunction: {
           // Declares a start function for a module.
@@ skipping 28 matching lines @@
           // Decode import table.
           for (uint32_t i = 0; i < import_table_count; i++) {
             if (failed()) break;
             TRACE("DecodeImportTable[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
 
             module->import_table.push_back({nullptr, 0, 0});
             WasmImport* import = &module->import_table.back();
 
             const byte* sigpos = pc_;
-            import->sig_index = consume_u16("signature index");
+            import->sig_index = consume_u32v(&length, "signature index");
 
             if (import->sig_index >= module->signatures.size()) {
               error(sigpos, "invalid signature index");
             } else {
               import->sig = module->signatures[import->sig_index];
             }
             import->module_name_offset = consume_string("import module name");
             import->function_name_offset =
                 consume_string("import function name");
           }
           break;
         }
         case kDeclExportTable: {
           // Declares an export table.
           CheckForPreviousSection(sections, kDeclFunctions, true);
           int length;
           uint32_t export_table_count =
               consume_u32v(&length, "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;
             TRACE("DecodeExportTable[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
 
             module->export_table.push_back({0, 0});
             WasmExport* exp = &module->export_table.back();
 
             const byte* sigpos = pc_;
-            exp->func_index = consume_u16("function index");
+            exp->func_index = consume_u32v(&length, "function index");
             if (exp->func_index >= module->functions.size()) {
               error(sigpos, sigpos,
                     "function index %u out of bounds (%d functions)",
                     exp->func_index,
                     static_cast<int>(module->functions.size()));
             }
             exp->name_offset = consume_string("export name");
           }
           break;
         }
@@ skipping 267 matching lines @@
       case kMemF64:
         return MachineType::Float64();
       default:
         error(pc_ - 1, "invalid memory type");
         return MachineType::None();
     }
   }
 
   // Parses an inline function signature.
   FunctionSig* consume_sig() {
-    byte count = consume_u8("param count");
+    int length;
+    byte count = consume_u32v(&length, "param count");
     LocalType ret = consume_local_type();
     FunctionSig::Builder builder(module_zone, ret == kAstStmt ? 0 : 1, count);
     if (ret != kAstStmt) builder.AddReturn(ret);
 
     for (int i = 0; i < count; i++) {
       LocalType param = consume_local_type();
       if (param == kAstStmt) error(pc_ - 1, "invalid void parameter type");
       builder.AddParam(param);
     }
     return builder.Build();
@@ skipping 55 matching lines @@
   if (function_start > function_end) return FunctionError("start > end");
   if (size > kMaxFunctionSize)
     return FunctionError("size > maximum function size");
   WasmFunction* function = new WasmFunction();
   ModuleDecoder decoder(zone, function_start, function_end, kWasmOrigin);
   return decoder.DecodeSingleFunction(module_env, function);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8