wasm: use strings for section 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 60 matching lines @@
       error(pos, pos,
             "expected version %02x %02x %02x %02x, "
             "found %02x %02x %02x %02x",
             BYTES(kWasmVersion), BYTES(magic_version));
       return toResult(module);
     }
 
     // Decode the module sections.
     while (pc_ < limit_) {
       TRACE("DecodeSection\n");
-      uint8_t section_u8 = consume_u8("section");
+      int length;
+      uint32_t section_bytes = consume_u32v(&length, "section size");

[titzer, 2016/03/07 08:45:33]

Should the section size also include the string size? (I think yes). In that
case the below code needs check the string is contained in the section size and
only skip the remaining bytes.

[JF, 2016/03/09 02:38:57]

Agreed, fixed.

 
-      if (section_u8 >= kMaxModuleSectionCode) {
+      WasmSectionDeclCode section = consume_section_name();
+      if (section == kMaxModuleSectionCode) {
         // Skip unknown section.
-        int length;
-        uint32_t section_bytes = consume_u32v(&length, "section size");
         consume_bytes(section_bytes);
         continue;
       }
 
       // Each section should appear at most once.
-      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:
           int length;
@@ skipping 411 matching lines @@
     return offset;
   }
 
   // Reads a single 32-bit unsigned integer interpreted as an offset into the
   // data and validating the string there and advances.
   uint32_t consume_string(const char* name = nullptr) {
     // TODO(titzer): validate string
     return consume_offset(name ? name : "string");
   }
 
+  // Reads a section name.
+  WasmSectionDeclCode consume_section_name() {
+    static const char* sections[] = {
+#define F(enumerator, string) string,
+        FOR_EACH_WASM_SECTION_TYPE(F)
+#undef F
+    };
+    static uint8_t sizes[] {
+#define F(enumerator, string) sizeof(string),
+        FOR_EACH_WASM_SECTION_TYPE(F)
+#undef F
+    };
+    static_assert(
+        sizeof(sections) / sizeof(sections[0]) == kMaxModuleSectionCode,
+        "expected enum WasmSectionDeclCode to be monotonic from 0");
+    int length;
+    uint32_t string_bytes = consume_u32v(&length, "section module name");
+    const byte* start = pc_;
+    consume_bytes(string_bytes);
+    if (failed()) return kMaxModuleSectionCode;
+    for (size_t i = 0; i != kMaxModuleSectionCode; ++i) {
+      if (sizes[i] == string_bytes &&
+          0 == memcmp(sections[i], start, string_bytes)) {
+        return (WasmSectionDeclCode)i;
+      }
+    }
+    return kMaxModuleSectionCode;
+  }
+
   // Reads a single 8-bit integer, interpreting it as a local type.
   LocalType consume_local_type() {
     byte val = consume_u8("local type");
     LocalTypeCode t = static_cast<LocalTypeCode>(val);
     switch (t) {
       case kLocalVoid:
         return kAstStmt;
       case kLocalI32:
         return kAstI32;
       case kLocalI64:
@@ skipping 110 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