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

test/cctest/wasm/wasm-run-utils.h

 // Copyright 2016 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 34 matching lines @@
 // exception.
 #define CHECK_TRAP32(x) \
   CHECK_EQ(0xdeadbeef, (bit_cast<uint32_t>(x)) & 0xFFFFFFFF)
 #define CHECK_TRAP64(x) \
   CHECK_EQ(0xdeadbeefdeadbeef, (bit_cast<uint64_t>(x)) & 0xFFFFFFFFFFFFFFFF)
 #define CHECK_TRAP(x) CHECK_TRAP32(x)
 
 #define WASM_RUNNER_MAX_NUM_PARAMETERS 4
 #define WASM_WRAPPER_RETURN_VALUE 8754
 
-#define BUILD(r, ...)                      \
-  do {                                     \
-    byte code[] = {__VA_ARGS__};           \
-    r.Build(code, code + arraysize(code)); \
+#define BUILD(r, ...)                             \
+  do {                                            \
+    byte code[] = {__VA_ARGS__};                  \
+    r.Build(code, code + arraysize(code), false); \
+  } while (false)
+
+#define BUILD_FAIL(r, ...)                       \
+  do {                                           \
+    byte code[] = {__VA_ARGS__};                 \
+    r.Build(code, code + arraysize(code), true); \
   } while (false)
 
 namespace {
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 using namespace v8::internal::wasm;
 
 const uint32_t kMaxGlobalsSize = 128;
 
@@ skipping 152 matching lines @@
         isolate_, ret_code, name,
         static_cast<int>(this->module->functions[index].sig->parameter_count()),
         exportedSig, module_object);
     return ret;
   }
 
   void SetFunctionCode(uint32_t index, Handle<Code> code) {
     instance->function_code[index] = code;
   }
 
-  void AddIndirectFunctionTable(uint16_t* functions, uint32_t table_size) {
-    module_.function_tables.push_back(
-        {table_size, table_size, std::vector<uint16_t>()});
+  void AddIndirectFunctionTable(FunctionSig* sig, uint32_t table,
+                                uint16_t* functions, uint32_t table_size) {
+    module_.function_tables.push_back({!module_.function_tables.size(), sig,
+                                       table, table_size, table_size,
+                                       std::vector<uint16_t>()});
     for (uint32_t i = 0; i < table_size; ++i) {
       module_.function_tables.back().values.push_back(functions[i]);
     }
 
     Handle<FixedArray> values = BuildFunctionTable(
         isolate_, static_cast<int>(module_.function_tables.size() - 1),
         &module_);
     instance->function_tables.push_back(values);
   }
 
@@ skipping 27 matching lines @@
     global_offset += size;
     // limit number of globals.
     CHECK_LT(global_offset, kMaxGlobalsSize);
     return &module->globals.back();
   }
 };
 
 inline void TestBuildingGraph(Zone* zone, JSGraph* jsgraph, ModuleEnv* module,
                               FunctionSig* sig,
                               SourcePositionTable* source_position_table,
-                              const byte* start, const byte* end) {
+                              const byte* start, const byte* end, bool fail) {
   compiler::WasmGraphBuilder builder(zone, jsgraph, sig, source_position_table);
   DecodeResult result =
       BuildTFGraph(zone->allocator(), &builder, module, sig, start, end);
-  if (result.failed()) {
+  if ((result.failed() && !fail) || (!result.failed() && fail)) {
     ptrdiff_t pc = result.error_pc - result.start;
     ptrdiff_t pt = result.error_pt - result.start;
     std::ostringstream str;
     str << "Verification failed: " << result.error_code << " pc = +" << pc;
     if (result.error_pt) str << ", pt = +" << pt;
     str << ", msg = " << result.error_msg.get();
     FATAL(str.str().c_str());
   }
+  if (result.failed()) return;
   builder.Int64LoweringForTesting();
   if (FLAG_trace_turbo_graph) {
     OFStream os(stdout);
     os << AsRPO(*jsgraph->graph());
   }
 }
 
 template <typename ReturnType>
 class WasmFunctionWrapper : public HandleAndZoneScope,
                             private GraphAndBuilders {
@@ skipping 210 matching lines @@
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   void InitializeDescriptor() {
     if (descriptor_ == nullptr) {
       descriptor_ = testing_module_->GetWasmCallDescriptor(main_zone(), sig);
     }
   }
   CallDescriptor* descriptor() { return descriptor_; }
   uint32_t function_index() { return function_->func_index; }
 
-  void Build(const byte* start, const byte* end) {
+  void Build(const byte* start, const byte* end, bool fail) {
     // Build the TurboFan graph.
     local_decls.Prepend(main_zone(), &start, &end);
     TestBuildingGraph(main_zone(), &jsgraph, testing_module_, sig,
-                      &source_position_table_, start, end);
-    if (interpreter_) {
+                      &source_position_table_, start, end, fail);
+    if (!fail && interpreter_) {
       // Add the code to the interpreter.
       CHECK(interpreter_->SetFunctionCodeForTesting(function_, start, end));
     }
   }
 
   byte AllocateLocal(LocalType type) {
     uint32_t index = local_decls.AddLocals(1, type);
     byte result = static_cast<byte>(index);
     DCHECK_EQ(index, result);
     return result;
@@ skipping 101 matching lines @@
     if (p3 != MachineType::None())
       storage_[index++] = WasmOpcodes::LocalTypeFor(p3);
 
     compiler_.InitializeDescriptor();
     wrapper_.Init(compiler_.descriptor(), p0, p1, p2, p3);
   }
 
   // Builds a graph from the given Wasm code and generates the machine
   // code and call wrapper for that graph. This method must not be called
   // more than once.
-  void Build(const byte* start, const byte* end) {
+  void Build(const byte* start, const byte* end, bool fail) {
     CHECK(!compiled_);
     compiled_ = true;
-    compiler_.Build(start, end);
+    compiler_.Build(start, end, fail);
 
-    if (!interpret()) {
+    if (!interpret() && !fail) {
       // Compile machine code and install it into the module.
       Handle<Code> code = compiler_.Compile();
 
       if (compiler_.testing_module_) {
         // Update the table of function code in the module.
         compiler_.testing_module_->SetFunctionCode(
             compiler_.function_->func_index, code);
       }
 
       wrapper_.SetInnerCode(code);
@@ skipping 107 matching lines @@
 // interpreter.
 #define WASM_EXEC_TEST(name)                                               \
   void RunWasm_##name(WasmExecutionMode execution_mode);                   \
   TEST(RunWasmCompiled_##name) { RunWasm_##name(kExecuteCompiled); }       \
   TEST(RunWasmInterpreted_##name) { RunWasm_##name(kExecuteInterpreted); } \
   void RunWasm_##name(WasmExecutionMode execution_mode)
 
 }  // namespace
 
 #endif