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

test/cctest/wasm/test-run-wasm.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/base/platform/elapsed-timer.h"
 
@@ skipping 912 matching lines @@
                                      WASM_GET_LOCAL(0), 3, BR_TARGET(cases[0]),
                                      BR_TARGET(cases[1]), BR_TARGET(cases[2]),
                                      BR_TARGET(cases[3]))),
                                  RET_I8(70)),
                               RET_I8(71)),
                            RET_I8(72)),
                         RET_I8(73)),
                      WASM_I8(75)};
 
       WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
-      r.Build(code, code + arraysize(code));
+      r.Build(code, code + arraysize(code), false);
 
       for (int x = -3; x < 50; ++x) {
         int index = (x > 3 || x < 0) ? 3 : x;
         int32_t expected = 70 + cases[index];
         CHECK_EQ(expected, r.Call(x));
       }
     }
   }
 }
 
 WASM_EXEC_TEST(BrTable4x4) {
   for (byte a = 0; a < 4; ++a) {
     for (byte b = 0; b < 4; ++b) {
       for (byte c = 0; c < 4; ++c) {
         for (byte d = 0; d < 4; ++d) {
           for (int i = 0; i < 4; ++i) {
             uint32_t cases[] = {a, b, c, d};
             byte code[] = {
                 B2(B2(B2(B2(B1(WASM_BR_TABLE(
                                 WASM_GET_LOCAL(0), 3, BR_TARGET(cases[0]),
                                 BR_TARGET(cases[1]), BR_TARGET(cases[2]),
                                 BR_TARGET(cases[3]))),
                             RET_I8(50)),
                          RET_I8(51)),
                       RET_I8(52)),
                    RET_I8(53)),
                 WASM_I8(55)};
 
             WasmRunner<int32_t> r(execution_mode, MachineType::Int32());
-            r.Build(code, code + arraysize(code));
+            r.Build(code, code + arraysize(code), false);
 
             for (int x = -6; x < 47; ++x) {
               int index = (x > 3 || x < 0) ? 3 : x;
               int32_t expected = 50 + cases[index];
               CHECK_EQ(expected, r.Call(x));
             }
           }
         }
       }
     }
   }
 }
 
 WASM_EXEC_TEST(BrTable4_fallthru) {
   byte code[] = {
       B2(B2(B2(B2(B1(WASM_BR_TABLE(WASM_GET_LOCAL(0), 3, BR_TARGET(0),
                                    BR_TARGET(1), BR_TARGET(2), BR_TARGET(3))),
                   WASM_INC_LOCAL_BY(1, 1)),
                WASM_INC_LOCAL_BY(1, 2)),
             WASM_INC_LOCAL_BY(1, 4)),
          WASM_INC_LOCAL_BY(1, 8)),
       WASM_GET_LOCAL(1)};
 
   WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
                         MachineType::Int32());
-  r.Build(code, code + arraysize(code));
+  r.Build(code, code + arraysize(code), false);
 
   CHECK_EQ(15, r.Call(0, 0));
   CHECK_EQ(14, r.Call(1, 0));
   CHECK_EQ(12, r.Call(2, 0));
   CHECK_EQ(8, r.Call(3, 0));
   CHECK_EQ(8, r.Call(4, 0));
 
   CHECK_EQ(115, r.Call(0, 100));
   CHECK_EQ(114, r.Call(1, 100));
   CHECK_EQ(112, r.Call(2, 100));
@@ skipping 771 matching lines @@
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(&zone, MachineType::PointerRepresentation(),
                                  MachineOperatorBuilder::kAllOptionalOps);
   Graph graph(&zone);
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
   FunctionSig* sig = WasmOpcodes::Signature(opcode);
 
   if (sig->parameter_count() == 1) {
     byte code[] = {WASM_NO_LOCALS, kExprGetLocal, 0, static_cast<byte>(opcode)};
     TestBuildingGraph(&zone, &jsgraph, nullptr, sig, nullptr, code,
-                      code + arraysize(code));
+                      code + arraysize(code), false);
   } else {
     CHECK_EQ(2, sig->parameter_count());
     byte code[] = {WASM_NO_LOCALS,           kExprGetLocal, 0, kExprGetLocal, 1,
                    static_cast<byte>(opcode)};
     TestBuildingGraph(&zone, &jsgraph, nullptr, sig, nullptr, code,
-                      code + arraysize(code));
+                      code + arraysize(code), false);
   }
 }
 
 TEST(Build_Wasm_SimpleExprs) {
 // Test that the decoder can build a graph for all supported simple expressions.
 #define GRAPH_BUILD_TEST(name, opcode, sig) \
   TestBuildGraphForSimpleExpression(kExpr##name);
 
   FOREACH_SIMPLE_OPCODE(GRAPH_BUILD_TEST);
 
@@ skipping 395 matching lines @@
              static_cast<byte>(index));
 
     // Store the result in memory.
     ADD_CODE(code,
              static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
              ZERO_ALIGNMENT, ZERO_OFFSET);
 
     // Return the expected value.
     ADD_CODE(code, WASM_I32V_2(kExpected));
 
-    r.Build(&code[0], &code[0] + code.size());
+    r.Build(&code[0], &code[0] + code.size(), false);
 
     // Run the code.
     for (int t = 0; t < 10; ++t) {
       module.RandomizeMemory();
       CHECK_EQ(kExpected, r.Call());
 
       int size = WasmOpcodes::MemSize(result);
       for (int i = 0; i < size; ++i) {
         int base = (which + 1) * kElemSize;
         byte expected = module.raw_mem_at<byte>(base + i);
@@ skipping 180 matching lines @@
   WasmFunctionCompiler t1(sigs.i_ii(), &module);
   BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   t1.CompileAndAdd(/*sig_index*/ 1);
 
   WasmFunctionCompiler t2(sigs.i_ii(), &module);
   BUILD(t2, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   t2.CompileAndAdd(/*sig_index*/ 1);
 
   // Signature table.
   module.AddSignature(sigs.f_ff());
-  module.AddSignature(sigs.i_ii());
+  byte index = module.AddSignature(sigs.i_ii());
   module.AddSignature(sigs.d_dd());
 
   // Function table.
   uint16_t indirect_function_table[] = {0, 1};
-  module.AddIndirectFunctionTable(indirect_function_table,
+  module.AddIndirectFunctionTable(sigs.i_ii(), index, indirect_function_table,
                                   arraysize(indirect_function_table));
   module.PopulateIndirectFunctionTable();
 
   // Builder the caller function.
   WasmRunner<int32_t> r(&module, MachineType::Int32());
-  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
+  BUILD(r,
+        WASM_CALL_INDIRECT2(1, 0, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
 
   CHECK_EQ(88, r.Call(0));
   CHECK_EQ(44, r.Call(1));
   CHECK_TRAP(r.Call(2));
 }
 
 WASM_EXEC_TEST(MultipleCallIndirect) {
   TestSignatures sigs;
   TestingModule module(execution_mode);
 
   WasmFunctionCompiler t1(sigs.i_ii(), &module);
   BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   t1.CompileAndAdd(/*sig_index*/ 1);
 
   WasmFunctionCompiler t2(sigs.i_ii(), &module);
   BUILD(t2, WASM_I32_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   t2.CompileAndAdd(/*sig_index*/ 1);
 
   // Signature table.
   module.AddSignature(sigs.f_ff());
-  module.AddSignature(sigs.i_ii());
+  byte index = module.AddSignature(sigs.i_ii());
   module.AddSignature(sigs.d_dd());
 
   // Function table.
   uint16_t indirect_function_table[] = {0, 1};
-  module.AddIndirectFunctionTable(indirect_function_table,
+  module.AddIndirectFunctionTable(sigs.i_ii(), index, indirect_function_table,
                                   arraysize(indirect_function_table));
   module.PopulateIndirectFunctionTable();
 
   // Builder the caller function.
   WasmRunner<int32_t> r(&module, MachineType::Int32(), MachineType::Int32(),
                         MachineType::Int32());
   BUILD(r, WASM_I32_ADD(
-               WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
+               WASM_CALL_INDIRECT2(1, 0, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1),
                                    WASM_GET_LOCAL(2)),
-               WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(1), WASM_GET_LOCAL(2),
+               WASM_CALL_INDIRECT2(1, 0, WASM_GET_LOCAL(1), WASM_GET_LOCAL(2),
                                    WASM_GET_LOCAL(0))));
 
   CHECK_EQ(5, r.Call(0, 1, 2));
   CHECK_EQ(19, r.Call(0, 1, 9));
   CHECK_EQ(1, r.Call(1, 0, 2));
   CHECK_EQ(1, r.Call(1, 0, 9));
 
   CHECK_TRAP(r.Call(0, 2, 1));
   CHECK_TRAP(r.Call(1, 2, 0));
   CHECK_TRAP(r.Call(2, 0, 1));
   CHECK_TRAP(r.Call(2, 1, 0));
 }
 
 WASM_EXEC_TEST(CallIndirect_NoTable) {
   TestSignatures sigs;
   TestingModule module(execution_mode);
 
   // One function.
   WasmFunctionCompiler t1(sigs.i_ii(), &module);
   BUILD(t1, WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   t1.CompileAndAdd(/*sig_index*/ 1);
 
   // Signature table.
   module.AddSignature(sigs.f_ff());
   module.AddSignature(sigs.i_ii());
 
   // Builder the caller function.
   WasmRunner<int32_t> r(&module, MachineType::Int32());
-  BUILD(r, WASM_CALL_INDIRECT2(1, WASM_GET_LOCAL(0), WASM_I8(66), WASM_I8(22)));
-
-  CHECK_TRAP(r.Call(0));
-  CHECK_TRAP(r.Call(1));
-  CHECK_TRAP(r.Call(2));
+  BUILD_FAIL(r, WASM_CALL_INDIRECT2(1, 0, WASM_GET_LOCAL(0), WASM_I8(66),
+                                    WASM_I8(22)));
 }
 
 WASM_EXEC_TEST(F32Floor) {
   WasmRunner<float> r(execution_mode, MachineType::Float32());
   BUILD(r, WASM_F32_FLOOR(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(F32Ceil) {
@@ skipping 238 matching lines @@
   // Make sure we don't run out of registers when compiling indirect calls
   // with many many parameters.
   TestSignatures sigs;
   for (byte num_params = 0; num_params < 40; ++num_params) {
     v8::base::AccountingAllocator allocator;
     Zone zone(&allocator);
     HandleScope scope(CcTest::InitIsolateOnce());
     TestingModule module(kExecuteCompiled);
     FunctionSig* sig = sigs.many(&zone, kAstStmt, param, num_params);
 
-    module.AddSignature(sig);
-    module.AddSignature(sig);
-    module.AddIndirectFunctionTable(nullptr, 0);
+    byte index = module.AddSignature(sig);
+    module.AddIndirectFunctionTable(sig, index, nullptr, 0);
 
     WasmFunctionCompiler t(sig, &module);
 
     std::vector<byte> code;
     ADD_CODE(code, kExprI8Const, 0);
     for (byte p = 0; p < num_params; ++p) {
       ADD_CODE(code, kExprGetLocal, p);
     }
-    ADD_CODE(code, kExprCallIndirect, static_cast<byte>(num_params), 1);
+    ADD_CODE(code, kExprCallIndirect, static_cast<byte>(num_params), index, 0);
 
-    t.Build(&code[0], &code[0] + code.size());
+    t.Build(&code[0], &code[0] + code.size(), false);
     t.Compile();
   }
 }
 
 TEST(Compile_Wasm_CallIndirect_Many_i32) { CompileCallIndirectMany(kAstI32); }
 
 TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
 
 TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }
 
 WASM_EXEC_TEST(Int32RemS_dead) {
   WasmRunner<int32_t> r(execution_mode, MachineType::Int32(),
                         MachineType::Int32());
   BUILD(r, WASM_I32_REMS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)), WASM_ZERO);
   const int32_t kMin = std::numeric_limits<int32_t>::min();
   CHECK_EQ(0, r.Call(133, 100));
   CHECK_EQ(0, r.Call(kMin, -1));
   CHECK_EQ(0, r.Call(0, 1));
   CHECK_TRAP(r.Call(100, 0));
   CHECK_TRAP(r.Call(-1001, 0));
   CHECK_TRAP(r.Call(kMin, 0));
 }