[wasm] Deleting unused parameter from function "consume_u32v"

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 92 matching lines @@
         goto done;
       }
     }
 
     // Decode the module sections.
     while (pc_ < limit_) {
       TRACE("DecodeSection\n");
       pos = pc_;
 
       // Read the section name.
-      int string_leb_length = 0;
-      uint32_t string_length =
-          consume_u32v(&string_leb_length, "section name length");
+      uint32_t string_length = consume_u32v("section name length");
       const byte* section_name_start = pc_;
       consume_bytes(string_length);
       if (failed()) {
         TRACE("Section name of length %u couldn't be read\n", string_length);
         break;
       }
 
       TRACE("  +%d  section name        : \"%.*s\"\n",
             static_cast<int>(section_name_start - start_),
             string_length < 20 ? string_length : 20, section_name_start);
 
       WasmSection::Code section =
           WasmSection::lookup(section_name_start, string_length);
 
       // Read and check the section size.
-      int section_leb_length = 0;
-      uint32_t section_length =
-          consume_u32v(&section_leb_length, "section length");
+      uint32_t section_length = consume_u32v("section length");
       if (!checkAvailable(section_length)) {
         // The section would extend beyond the end of the module.
         break;
       }
       const byte* section_start = pc_;
       const byte* expected_section_end = pc_ + section_length;
 
       current_order = CheckSectionOrder(current_order, section);
 
       switch (section) {
         case WasmSection::Code::End:
           // Terminate section decoding.
           limit_ = pc_;
           break;
         case WasmSection::Code::Memory: {
-          int length;
-          module->min_mem_pages = consume_u32v(&length, "min memory");
-          module->max_mem_pages = consume_u32v(&length, "max 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: {
-          int length;
-          uint32_t signatures_count = consume_u32v(&length, "signatures count");
+          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;
             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: {
-          int length;
-          uint32_t functions_count = consume_u32v(&length, "functions count");
+          uint32_t functions_count = consume_u32v("functions count");
           module->functions.reserve(SafeReserve(functions_count));
           for (uint32_t i = 0; 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: {
-          int length;
           const byte* pos = pc_;
-          uint32_t functions_count = consume_u32v(&length, "functions count");
+          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) {
             WasmFunction* function = &module->functions[i];
-            int length;
-            uint32_t size = consume_u32v(&length, "body size");
+            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: {
-          int length;
           const byte* pos = pc_;
-          uint32_t functions_count = consume_u32v(&length, "functions count");
+          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) {
             WasmFunction* function = &module->functions[i];
             function->name_offset =
                 consume_string(&function->name_length, false);
 
-            uint32_t local_names_count =
-                consume_u32v(&length, "local names count");
+            uint32_t local_names_count = consume_u32v("local names count");
             for (uint32_t j = 0; 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: {
-          int length;
-          uint32_t globals_count = consume_u32v(&length, "globals count");
+          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;
             TRACE("DecodeGlobal[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
             module->globals.push_back({0, 0, MachineType::Int32(), 0, false});
             WasmGlobal* global = &module->globals.back();
             DecodeGlobalInModule(global);
           }
           break;
         }
         case WasmSection::Code::DataSegments: {
-          int length;
-          uint32_t data_segments_count =
-              consume_u32v(&length, "data segments count");
+          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;
             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::FunctionTablePad: {
           if (!FLAG_wasm_jit_prototype) {
             error("FunctionTablePad section without jiting enabled");
           }
           // An indirect function table requires functions first.
-          int length;
-          module->indirect_table_size =
-              consume_u32v(&length, "indirect entry count");
+          module->indirect_table_size = consume_u32v("indirect entry count");
           if (module->indirect_table_size > 0 &&
               module->indirect_table_size < module->function_table.size()) {
             error("more predefined indirect entries than table can hold");
           }
           break;
         }
         case WasmSection::Code::FunctionTable: {
           // An indirect function table requires functions first.
           CheckForFunctions(module, section);
-          int length;
-          uint32_t function_table_count =
-              consume_u32v(&length, "function table count");
+          uint32_t function_table_count = consume_u32v("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_u32v(&length);
+            uint16_t index = consume_u32v();
             if (index >= module->functions.size()) {
               error(pc_ - 2, "invalid function index");
               break;
             }
             module->function_table.push_back(index);
           }
           if (module->indirect_table_size > 0 &&
               module->indirect_table_size < module->function_table.size()) {
             error("more predefined indirect entries than table can hold");
           }
           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: {
-          int length;
-          uint32_t import_table_count =
-              consume_u32v(&length, "import table count");
+          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;
             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
@@ skipping 10 matching lines @@
               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);
-          int length;
-          uint32_t export_table_count =
-              consume_u32v(&length, "export table count");
+          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;
             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
@@ skipping 135 matching lines @@
 
   bool IsWithinLimit(uint32_t limit, uint32_t offset, uint32_t size) {
     if (offset > limit) return false;
     if ((offset + size) < offset) return false;  // overflow
     return (offset + size) <= limit;
   }
 
   // Decodes a single data segment entry inside a module starting at {pc_}.
   void DecodeDataSegmentInModule(WasmModule* module, WasmDataSegment* segment) {
     const byte* start = pc_;
-    int length;
-    segment->dest_addr = consume_u32v(&length, "destination");
-    segment->source_size = consume_u32v(&length, "source size");
+    segment->dest_addr = consume_u32v("destination");
+    segment->source_size = consume_u32v("source size");
     segment->source_offset = static_cast<uint32_t>(pc_ - start_);
     segment->init = true;
 
     // Validate the data is in the module.
     uint32_t module_limit = static_cast<uint32_t>(limit_ - start_);
     if (!IsWithinLimit(module_limit, segment->source_offset,
                        segment->source_size)) {
       error(start, "segment out of bounds of module");
     }
 
@@ skipping 61 matching lines @@
     uint32_t offset = consume_u32(name ? name : "offset");
     if (offset > static_cast<uint32_t>(limit_ - start_)) {
       error(pc_ - sizeof(uint32_t), "offset out of bounds of module");
     }
     return offset;
   }
 
   // Reads a length-prefixed string, checking that it is within bounds. Returns
   // the offset of the string, and the length as an out parameter.
   uint32_t consume_string(uint32_t* length, bool validate_utf8) {
-    int varint_length;
-    *length = consume_u32v(&varint_length, "string length");
+    *length = consume_u32v("string length");
     uint32_t offset = pc_offset();
     TRACE("  +%u  %-20s: (%u bytes)\n", offset, "string", *length);
     if (validate_utf8 && !unibrow::Utf8::Validate(pc_, *length)) {
       error(pc_, "no valid UTF-8 string");
     }
     consume_bytes(*length);
     return offset;
   }
 
   uint32_t consume_sig_index(WasmModule* module, FunctionSig** sig) {
     const byte* pos = pc_;
-    int length;
-    uint32_t sig_index = consume_u32v(&length, "signature index");
+    uint32_t sig_index = consume_u32v("signature index");
     if (sig_index >= module->signatures.size()) {
       error(pos, pos, "signature index %u out of bounds (%d signatures)",
             sig_index, static_cast<int>(module->signatures.size()));
       *sig = nullptr;
       return 0;
     }
     *sig = module->signatures[sig_index];
     return sig_index;
   }
 
   uint32_t consume_func_index(WasmModule* module, WasmFunction** func) {
     const byte* pos = pc_;
-    int length;
-    uint32_t func_index = consume_u32v(&length, "function index");
+    uint32_t func_index = consume_u32v("function index");
     if (func_index >= module->functions.size()) {
       error(pos, pos, "function index %u out of bounds (%d functions)",
             func_index, static_cast<int>(module->functions.size()));
       *func = nullptr;
       return 0;
     }
     *func = &module->functions[func_index];
     return func_index;
   }
 
@@ skipping 53 matching lines @@
 
   // Parses a type entry, which is currently limited to functions only.
   FunctionSig* consume_sig() {
     const byte* pos = pc_;
     byte form = consume_u8("type form");
     if (form != kWasmFunctionTypeForm) {
       error(pos, pos, "expected function type form (0x%02x), got: 0x%02x",
             kWasmFunctionTypeForm, form);
       return nullptr;
     }
-    int length;
     // parse parameter types
-    uint32_t param_count = consume_u32v(&length, "param count");
+    uint32_t param_count = consume_u32v("param count");
     std::vector<LocalType> params;
     for (uint32_t i = 0; i < param_count; ++i) {
       LocalType param = consume_local_type();
       if (param == kAstStmt) error(pc_ - 1, "invalid void parameter type");
       params.push_back(param);
     }
 
     // parse return types
     const byte* pt = pc_;
-    uint32_t return_count = consume_u32v(&length, "return count");
+    uint32_t return_count = consume_u32v("return count");
     if (return_count > kMaxReturnCount) {
       error(pt, pt, "return count of %u exceeds maximum of %u", return_count,
             kMaxReturnCount);
       return nullptr;
     }
     std::vector<LocalType> returns;
     for (uint32_t i = 0; i < return_count; ++i) {
       LocalType ret = consume_local_type();
       if (ret == kAstStmt) error(pc_ - 1, "invalid void return type");
       returns.push_back(ret);
@@ skipping 41 matching lines @@
   Decoder decoder(module_start, module_end);
 
   uint32_t magic_word = decoder.consume_u32("wasm magic");
   if (magic_word != kWasmMagic) decoder.error("wrong magic word");
 
   uint32_t magic_version = decoder.consume_u32("wasm version");
   if (magic_version != kWasmVersion) decoder.error("wrong wasm version");
 
   while (decoder.more() && decoder.ok()) {
     // Read the section name.
-    int string_leb_length = 0;
-    uint32_t string_length =
-        decoder.consume_u32v(&string_leb_length, "section name length");
+    uint32_t string_length = decoder.consume_u32v("section name length");
     const byte* section_name_start = decoder.pc();
     decoder.consume_bytes(string_length);
     if (decoder.failed()) break;
 
     WasmSection::Code section =
         WasmSection::lookup(section_name_start, string_length);
 
     // Read and check the section size.
-    int section_leb_length = 0;
-    uint32_t section_length =
-        decoder.consume_u32v(&section_leb_length, "section length");
+    uint32_t section_length = decoder.consume_u32v("section length");
 
     const byte* section_start = decoder.pc();
     decoder.consume_bytes(section_length);
     if (section == code && decoder.ok()) {
       return Vector<const uint8_t>(section_start, section_length);
     }
   }
 
   return Vector<const uint8_t>();
 }
@@ skipping 44 matching lines @@
   return decoder.DecodeSingleFunction(module_env, function);
 }
 
 FunctionOffsetsResult DecodeWasmFunctionOffsets(const byte* module_start,
                                                 const byte* module_end) {
   Vector<const byte> code_section =
       FindSection(module_start, module_end, WasmSection::Code::FunctionBodies);
   Decoder decoder(code_section.start(), code_section.end());
   if (!code_section.start()) decoder.error("no code section");
 
-  int length;
-  uint32_t functions_count = decoder.consume_u32v(&length, "functions count");
+  uint32_t functions_count = decoder.consume_u32v("functions count");
   FunctionOffsets table;
   // Take care of invalid input here.
   if (functions_count < static_cast<unsigned>(code_section.length()) / 2)
     table.reserve(functions_count);
   int section_offset = static_cast<int>(code_section.start() - module_start);
   DCHECK_LE(0, section_offset);
   for (uint32_t i = 0; i < functions_count && decoder.ok(); ++i) {
-    uint32_t size = decoder.consume_u32v(&length, "body size");
+    uint32_t size = decoder.consume_u32v("body size");
     int offset = static_cast<int>(section_offset + decoder.pc_offset());
     table.push_back(std::make_pair(offset, static_cast<int>(size)));
     DCHECK(table.back().first >= 0 && table.back().second >= 0);
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8