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

test/cctest/wasm/test-run-wasm-interpreter.cc

 // 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.
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 
@@ skipping 40 matching lines @@
 TEST(Run_WasmNopsN) {
   const int kMaxNops = 10;
   byte code[kMaxNops + 2];
   for (int nops = 0; nops < kMaxNops; nops++) {
     byte expected = static_cast<byte>(20 + nops);
     memset(code, kExprNop, sizeof(code));
     code[nops] = kExprI8Const;
     code[nops + 1] = expected;
 
     WasmRunner<int32_t> r(kExecuteInterpreted);
-    r.Build(code, code + nops + 2);
+    r.Build(code, code + nops + 2, false);
     CHECK_EQ(expected, r.Call());
   }
 }
 
 TEST(Run_WasmConstsN) {
   const int kMaxConsts = 10;
   byte code[kMaxConsts * 2];
   for (int count = 1; count < kMaxConsts; count++) {
     for (int i = 0; i < count; i++) {
       code[i * 2] = kExprI8Const;
       code[i * 2 + 1] = static_cast<byte>(count * 10 + i);
     }
     byte expected = static_cast<byte>(count * 11 - 1);
 
     WasmRunner<int32_t> r(kExecuteInterpreted);
-    r.Build(code, code + (count * 2));
+    r.Build(code, code + (count * 2), false);
     CHECK_EQ(expected, r.Call());
   }
 }
 
 TEST(Run_WasmBlocksN) {
   const int kMaxNops = 10;
   const int kExtra = 4;
   byte code[kMaxNops + kExtra];
   for (int nops = 0; nops < kMaxNops; nops++) {
     byte expected = static_cast<byte>(30 + nops);
     memset(code, kExprNop, sizeof(code));
     code[0] = kExprBlock;
     code[1 + nops] = kExprI8Const;
     code[1 + nops + 1] = expected;
     code[1 + nops + 2] = kExprEnd;
 
     WasmRunner<int32_t> r(kExecuteInterpreted);
-    r.Build(code, code + nops + kExtra);
+    r.Build(code, code + nops + kExtra, false);
     CHECK_EQ(expected, r.Call());
   }
 }
 
 TEST(Run_WasmBlockBreakN) {
   const int kMaxNops = 10;
   const int kExtra = 6;
   byte code[kMaxNops + kExtra];
   for (int nops = 0; nops < kMaxNops; nops++) {
     // Place the break anywhere within the block.
     for (int index = 0; index < nops; index++) {
       memset(code, kExprNop, sizeof(code));
       code[0] = kExprBlock;
       code[sizeof(code) - 1] = kExprEnd;
 
       int expected = nops * 11 + index;
       code[1 + index + 0] = kExprI8Const;
       code[1 + index + 1] = static_cast<byte>(expected);
       code[1 + index + 2] = kExprBr;
       code[1 + index + 3] = ARITY_1;
       code[1 + index + 4] = 0;
 
       WasmRunner<int32_t> r(kExecuteInterpreted);
-      r.Build(code, code + kMaxNops + kExtra);
+      r.Build(code, code + kMaxNops + kExtra, false);
       CHECK_EQ(expected, r.Call());
     }
   }
 }
 
 TEST(Run_Wasm_nested_ifs_i) {
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Int32(),
                         MachineType::Int32());
 
   BUILD(r, WASM_IF_ELSE(
@@ skipping 38 matching lines @@
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 3;
   byte code[] = {WASM_I32_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
   std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprGetLocal, kExprGetLocal,
            kExprI32Add);
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
-  r.Build(code, code + arraysize(code));
+  r.Build(code, code + arraysize(code), false);
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
   for (int i = 0; i < kNumBreakpoints; i++) {
     interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[i],
                                true);
   }
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
@@ skipping 18 matching lines @@
   }
 }
 
 TEST(Step_I32Mul) {
   static const int kTraceLength = 4;
   byte code[] = {WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
-  r.Build(code, code + arraysize(code));
+  r.Build(code, code + arraysize(code), false);
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 33; b < 3000000000u; b += 1000000000u) {
       thread->Reset();
       WasmVal args[] = {WasmVal(*a), WasmVal(b)};
       thread->PushFrame(r.function(), args);
 
@@ skipping 18 matching lines @@
 TEST(Breakpoint_I32And_disable) {
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 1;
   byte code[] = {WASM_I32_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
   std::unique_ptr<int[]> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprI32And);
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
-  r.Build(code, code + arraysize(code));
+  r.Build(code, code + arraysize(code), false);
 
   WasmInterpreter* interpreter = r.interpreter();
   WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
       // Run with and without breakpoints.
       for (int do_break = 0; do_break < 2; do_break++) {
         interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[0],
                                    do_break);
@@ skipping 15 matching lines @@
         uint32_t expected = (*a) & (b);
         CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
       }
     }
   }
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8