[wasm] Experimental: Add support for multiple non-homogeneous tables

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 242 matching lines @@
                                              0,        // source_size
                                              false});  // init
             WasmDataSegment* segment = &module->data_segments.back();
             DecodeDataSegmentInModule(module, segment);
           }
           break;
         }
         case WasmSection::Code::FunctionTable: {
           // An indirect function table requires functions first.
           CheckForFunctions(module, section);
-          // Assume only one table for now.
-          static const uint32_t kSupportedTableCount = 1;
-          module->function_tables.reserve(SafeReserve(kSupportedTableCount));
+          uint32_t table_count = consume_u32v("function table count");
+          module->function_tables.reserve(SafeReserve(table_count));
           // Decode function table.
-          for (uint32_t i = 0; i < kSupportedTableCount; ++i) {
+          for (uint32_t i = 0; i < table_count; ++i) {
             if (failed()) break;
             TRACE("DecodeFunctionTable[%d] module+%d\n", i,
                   static_cast<int>(pc_ - start_));
-            module->function_tables.push_back({0, 0, std::vector<uint16_t>()});
-            DecodeFunctionTableInModule(module, &module->function_tables[i]);
+            module->function_tables.push_back(
+                {!i,                         // default
+                 nullptr,                    // sig
+                 0,                          // sig_index
+                 0,                          // size
+                 0,                          // max_size
+                 std::vector<uint16_t>()});  // vals
+            DecodeFunctionTableInModule(module,
+                                        &module->function_tables.back());
           }
           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;
           }
@@ skipping 216 matching lines @@
                        segment->source_size)) {
       error(start, "segment out of bounds of memory");
     }
 
     consume_bytes(segment->source_size);
   }
 
   // Decodes a single function table inside a module starting at {pc_}.
   void DecodeFunctionTableInModule(WasmModule* module,
                                    WasmIndirectFunctionTable* table) {
+    table->isDefault = consume_u8("default");
+    if (table->isDefault && module->function_tables.size() > 1) {
+      error("invalid default flag");
+    }
+    table->sig_index = consume_sig_index(module, &table->sig);
+
     table->size = consume_u32v("function table entry count");
-    table->max_size = table->size;
+    table->max_size = consume_u32v();
 
     if (table->max_size != table->size) {
       error("invalid table maximum size");
     }
 
     for (uint32_t i = 0; i < table->size; ++i) {
       uint16_t index = consume_u32v();
       if (index >= module->functions.size()) {
         error(pc_ - sizeof(index), "invalid function index");
         break;
       }
+      if (!isAnyFuncType(table->sig) &&
+          module->functions[index].sig != table->sig) {
+        error("invalid function signature type");
+        break;
+      }
       table->values.push_back(index);
     }
   }
 
   // Calculate individual global offsets and total size of globals table.
   void CalculateGlobalsOffsets(WasmModule* module) {
     uint32_t offset = 0;
     if (module->globals.size() == 0) {
       module->globals_size = 0;
       return;
@@ skipping 115 matching lines @@
     if (form != kWasmFunctionTypeForm) {
       error(pos, pos, "expected function type form (0x%02x), got: 0x%02x",
             kWasmFunctionTypeForm, form);
       return nullptr;
     }
     // parse parameter types
     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");
+      if (param == kAstStmt && i) error(pc_ - 1, "invalid void parameter type");
       params.push_back(param);
     }
 
     // parse return types
     const byte* pt = pc_;
     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);
     }
 
+    // Check if a parameter is kAstStmt but it is not the special kAnyFunc type
+    if (param_count == 1 && params[0] == kAstStmt && return_count != 0)
+      error(pc_ - 1, "invalid void parameter type");
+
     // FunctionSig stores the return types first.
     LocalType* buffer =
         module_zone->NewArray<LocalType>(param_count + return_count);
     uint32_t b = 0;
     for (uint32_t i = 0; i < return_count; ++i) buffer[b++] = returns[i];
     for (uint32_t i = 0; i < param_count; ++i) buffer[b++] = params[i];
 
     return new (module_zone) FunctionSig(return_count, param_count, buffer);
   }
 };
@@ skipping 125 matching lines @@
     decoder.consume_bytes(size);
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8