WebAssembly: skip unknown sections, add names

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 38 matching lines @@
     module->max_mem_size_log2 = 0;
     module->mem_export = false;
     module->mem_external = false;
     module->globals = new std::vector<WasmGlobal>();
     module->signatures = new std::vector<FunctionSig*>();
     module->functions = new std::vector<WasmFunction>();
     module->data_segments = new std::vector<WasmDataSegment>();
     module->function_table = new std::vector<uint16_t>();
     module->import_table = new std::vector<WasmImport>();
 
-    bool sections[kMaxModuleSectionCode];
-    memset(sections, 0, sizeof(sections));
+    bool sections[kMaxModuleSectionCode] = {false};
 
     // Decode the module sections.
-    while (pc_ < limit_) {
+    while (pc_ < limit_ && !failed()) {
       TRACE("DecodeSection\n");
-      WasmSectionDeclCode section =
-          static_cast<WasmSectionDeclCode>(consume_u8("section"));
+      uint8_t section_u8 = consume_u8("section");
+
+      if (section_u8 >= kMaxModuleSectionCode) {
+        // Skip unknown section.
+        int length;
+        for (uint32_t section_bytes = consume_u32v(&length, "globals count");

[titzer, 2016/02/26 22:54:17]

s/globals count/section size/

[JF, 2016/02/26 23:42:41]

Done.

+             section_bytes; --section_bytes) {
+          if (failed()) break;
+          (void)consume_u8("unknown section byte");

[titzer, 2016/02/26 22:54:17]

You can just consume the length and then increment the pc_ (maybe add a method
to decoder.h)

[JF, 2016/02/26 23:42:41]

Done.

+        }
+        continue;
+      }
+
       // Each section should appear at most once.
-      if (section < kMaxModuleSectionCode) {
-        CheckForPreviousSection(sections, section, false);
-        sections[section] = true;
-      }
+      auto section = static_cast<WasmSectionDeclCode>(section_u8);
+      CheckForPreviousSection(sections, section, false);
+      sections[section] = true;
 
       switch (section) {
         case kDeclEnd:
           // Terminate section decoding.
           limit_ = pc_;
           break;
         case kDeclMemory:
           module->min_mem_size_log2 = consume_u8("min memory");
           module->max_mem_size_log2 = consume_u8("max memory");
           module->mem_export = consume_u8("export memory") != 0;
@@ skipping 145 matching lines @@
               error(sigpos, "invalid signature index");
             } else {
               import->sig = module->signatures->at(import->sig_index);
             }
             import->module_name_offset = consume_string("import module name");
             import->function_name_offset =
                 consume_string("import function name");
           }
           break;
         }
-        case kDeclWLL: {
-          // Reserved for experimentation by the Web Low-level Language project
-          // which is augmenting the binary encoding with source code meta
-          // information. This section does not affect the semantics of the code
-          // and can be ignored by the runtime. https://github.com/JSStats/wll
-          int length = 0;
-          uint32_t section_size = consume_u32v(&length, "section size");
-          if (pc_ + section_size > limit_ || pc_ + section_size < pc_) {
-            error(pc_ - length, "invalid section size");
-            break;
-          }
-          pc_ += section_size;
-          break;
-        }
-        default:
-          error(pc_ - 1, nullptr, "unrecognized section 0x%02x", section);
-          break;
+        case kMaxModuleSectionCode:
+          UNREACHABLE();  // Already skipped unknown sections.
       }
     }
 
     return toResult(module);
   }
 
   uint32_t SafeReserve(uint32_t count) {
     // Avoid OOM by only reserving up to a certain size.
     const uint32_t kMaxReserve = 20000;
     return count < kMaxReserve ? count : kMaxReserve;
@@ skipping 343 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, false);
   return decoder.DecodeSingleFunction(module_env, function);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8