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 33 matching lines @@
   ModuleResult DecodeModule(WasmModule* module, bool verify_functions = true) {
     pc_ = start_;
     module->module_start = start_;
     module->module_end = limit_;
     module->min_mem_pages = 0;
     module->max_mem_pages = 0;
     module->mem_export = false;
     module->mem_external = false;
     module->origin = origin_;
 
-    bool sections[kMaxModuleSectionCode] = {false};
+    bool sections[(size_t)WasmSection::Code::Max] = {false};
 
     const byte* pos = pc_;
     uint32_t magic_word = consume_u32("wasm magic");
 #define BYTES(x) (x & 0xff), (x >> 8) & 0xff, (x >> 16) & 0xff, (x >> 24) & 0xff
     if (magic_word != kWasmMagic) {
       error(pos, pos,
             "expected magic word %02x %02x %02x %02x, "
             "found %02x %02x %02x %02x",
             BYTES(kWasmMagic), BYTES(magic_word));
       return toResult(module);
     }
 
     pos = pc_;
     uint32_t magic_version = consume_u32("wasm version");
     if (magic_version != kWasmVersion) {
       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");
+      pos = pc_;
 
-      if (section_u8 >= kMaxModuleSectionCode) {
+      int length;
+      uint32_t section_bytes = consume_u32v(&length, "section size");

[titzer, 2016/03/09 13:19:37]

section_size

*_bytes sounds like it might refer to the actual data.

[JF, 2016/03/09 18:51:52]

Done.

+
+      uint32_t section_string_bytes;

[titzer, 2016/03/09 13:19:37]

section_string_size

[JF, 2016/03/09 18:51:52]

Done.

+      WasmSection::Code section = consume_section_name(&section_string_bytes);
+      if (section_string_bytes > section_bytes) {
+        error(pos, pos,
+              "section string of size %u longer than total section bytes %u",
+              section_string_bytes, section_bytes);
+        break;
+      }
+
+      if (section == WasmSection::Code::Max) {
         // Skip unknown section.
-        int length;
-        uint32_t section_bytes = consume_u32v(&length, "section size");
-        consume_bytes(section_bytes);
+        consume_bytes(section_bytes - section_string_bytes);
         continue;
       }
 
       // Each section should appear at most once.
-      auto section = static_cast<WasmSectionDeclCode>(section_u8);
       CheckForPreviousSection(sections, section, false);
-      sections[section] = true;
+      sections[(size_t)section] = true;
 
       switch (section) {
-        case kDeclEnd:
+        case WasmSection::Code::End:
           // Terminate section decoding.
           limit_ = pc_;
           break;
-        case kDeclMemory:
+        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->mem_export = consume_u8("export memory") != 0;
           break;
-        case kDeclSignatures: {
+        case WasmSection::Code::Signatures: {
           int length;
           uint32_t signatures_count = consume_u32v(&length, "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();  // read function sig.
             module->signatures.push_back(s);
           }
           break;
         }
-        case kDeclFunctions: {
+        case WasmSection::Code::Functions: {
           // Functions require a signature table first.
-          CheckForPreviousSection(sections, kDeclSignatures, true);
+          CheckForPreviousSection(sections, WasmSection::Code::Signatures, true);
           int length;
           uint32_t functions_count = consume_u32v(&length, "functions count");
           module->functions.reserve(SafeReserve(functions_count));
           // Set up module environment for verification.
           ModuleEnv menv;
           menv.module = module;
           menv.instance = nullptr;
           menv.origin = origin_;
           // Decode functions.
           for (uint32_t i = 0; i < functions_count; i++) {
@@ skipping 12 matching lines @@
               WasmFunction* function = &module->functions[i];
               if (!function->external) {
                 VerifyFunctionBody(i, &menv, function);
                 if (result_.failed())
                   error(result_.error_pc, result_.error_msg.get());
               }
             }
           }
           break;
         }
-        case kDeclGlobals: {
+        case WasmSection::Code::Globals: {
           int length;
           uint32_t globals_count = consume_u32v(&length, "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, MachineType::Int32(), 0, false});
             WasmGlobal* global = &module->globals.back();
             DecodeGlobalInModule(global);
           }
           break;
         }
-        case kDeclDataSegments: {
+        case WasmSection::Code::DataSegments: {
           int length;
           uint32_t data_segments_count =
               consume_u32v(&length, "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, 0, 0});
             WasmDataSegment* segment = &module->data_segments.back();
             DecodeDataSegmentInModule(module, segment);
           }
           break;
         }
-        case kDeclFunctionTable: {
+        case WasmSection::Code::FunctionTable: {
           // An indirect function table requires functions first.
-          CheckForPreviousSection(sections, kDeclFunctions, true);
+          CheckForPreviousSection(sections, WasmSection::Code::Functions, 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();
             if (index >= module->functions.size()) {
               error(pc_ - 2, "invalid function index");
               break;
             }
             module->function_table.push_back(index);
           }
           break;
         }
-        case kDeclStartFunction: {
+        case WasmSection::Code::StartFunction: {
           // Declares a start function for a module.
-          CheckForPreviousSection(sections, kDeclFunctions, true);
+          CheckForPreviousSection(sections, WasmSection::Code::Functions, true);
           if (module->start_function_index >= 0) {
             error("start function already declared");
             break;
           }
           int length;
           const byte* before = pc_;
           uint32_t index = consume_u32v(&length, "start function index");
           if (index >= module->functions.size()) {
             error(before, "invalid start function index");
             break;
           }
           module->start_function_index = static_cast<int>(index);
           FunctionSig* sig =
               module->signatures[module->functions[index].sig_index];
           if (sig->parameter_count() > 0) {
             error(before, "invalid start function: non-zero parameter count");
             break;
           }
           break;
         }
-        case kDeclImportTable: {
+        case WasmSection::Code::ImportTable: {
           // Declares an import table.
-          CheckForPreviousSection(sections, kDeclSignatures, true);
+          CheckForPreviousSection(sections, WasmSection::Code::Signatures, true);
           int length;
           uint32_t import_table_count =
               consume_u32v(&length, "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, 0, 0});
             WasmImport* import = &module->import_table.back();
 
             const byte* sigpos = pc_;
             import->sig_index = consume_u16("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: {
+        case WasmSection::Code::ExportTable: {
           // Declares an export table.
-          CheckForPreviousSection(sections, kDeclFunctions, true);
+          CheckForPreviousSection(sections, WasmSection::Code::Functions, 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");
             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;
         }
-        case kMaxModuleSectionCode:
+        case WasmSection::Code::Max:
           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;
   }
 
-  void CheckForPreviousSection(bool* sections, WasmSectionDeclCode section,
+  void CheckForPreviousSection(bool* sections, WasmSection::Code section,
                                bool present) {
-    if (section >= kMaxModuleSectionCode) return;
-    if (sections[section] == present) return;
-    const char* name = "";
-    switch (section) {
-      case kDeclMemory:
-        name = "memory";
-        break;
-      case kDeclSignatures:
-        name = "signatures";
-        break;
-      case kDeclFunctions:
-        name = "function declaration";
-        break;
-      case kDeclGlobals:
-        name = "global variable";
-        break;
-      case kDeclDataSegments:
-        name = "data segment";
-        break;
-      case kDeclFunctionTable:
-        name = "function table";
-        break;
-      default:
-        name = "";
-        break;
-    }
+    if (section >= WasmSection::Code::Max) return;
+    if (sections[(size_t)section] == present) return;
     if (present) {
-      error(pc_ - 1, nullptr, "required %s section missing", name);
+      error(pc_ - 1, nullptr, "required %s section missing",
+            WasmSection::getName(section));
     } else {
-      error(pc_ - 1, nullptr, "%s section already present", name);
+      error(pc_ - 1, nullptr, "%s section already present",
+            WasmSection::getName(section));
     }
   }
 
   // Decodes a single anonymous function starting at {start_}.
   FunctionResult DecodeSingleFunction(ModuleEnv* module_env,
                                       WasmFunction* function) {
     pc_ = start_;
     function->sig = consume_sig();               // read signature
     function->name_offset = 0;                   // ---- name
     function->code_start_offset = off(pc_);      // ---- code start
@@ skipping 157 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.
+  WasmSection::Code consume_section_name(uint32_t* string_bytes) {
+    int length;
+    *string_bytes = consume_u32v(&length, "name length");
+    const byte* start = pc_;
+    consume_bytes(*string_bytes);
+    if (failed()) {
+      TRACE("Section name of length %u couldn't be read\n", *string_bytes);
+      return WasmSection::Code::Max;
+    }
+    for (WasmSection::Code i = WasmSection::begin(); i != WasmSection::end();
+         i = WasmSection::next(i)) {
+      if (WasmSection::getNameLength(i) == *string_bytes &&

[titzer, 2016/03/09 13:19:37]

Can you drop in a TODO here? It's a linear search...

[JF, 2016/03/09 18:51:52]

Done.

+          0 == memcmp(WasmSection::getName(i), start, *string_bytes)) {
+        return i;
+      }
+    }
+    TRACE("Unknown section: '%*s'\n", *string_bytes, start);
+    return WasmSection::Code::Max;
+  }
+
   // 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