[wasm] Add an export table.

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 37 matching lines @@
     module->min_mem_size_log2 = 0;
     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>();
+    module->export_table = new std::vector<WasmExport>();
 
     bool sections[kMaxModuleSectionCode];
     memset(sections, 0, sizeof(sections));
 
     // Decode the module sections.
     while (pc_ < limit_) {
       TRACE("DecodeSection\n");
       WasmSectionDeclCode section =
           static_cast<WasmSectionDeclCode>(consume_u8("section"));
       // Each section should appear at most once.
@@ skipping 159 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 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");
+            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 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;
@@ skipping 360 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