[wasm] Binary 11: AST changes.

test/cctest/wasm/test-run-wasm-64.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/bits.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/test-signatures.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 
 #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 asi64(x) static_cast<int64_t>(x)
 
 #define asu64(x) static_cast<uint64_t>(x)
 
-#define B2(a, b) kExprBlock, 2, a, b
-#define B1(a) kExprBlock, 1, a
+#define B2(a, b) kExprBlock, a, b, kExprEnd
+#define B1(a) kExprBlock, a, kExprEnd
 
 // Can't bridge macro land with nested macros.
 #if V8_TARGET_ARCH_MIPS
 #define MIPS true
 #else
 #define MIPS false
 #endif
 
 #define FOREACH_I64_OPERATOR(V) \
   V(DepthFirst, true)           \
@@ skipping 70 matching lines @@
     BUILD(r, WASM_I64V(kExpectedValue));
     CHECK_EQ(kExpectedValue, r.Call());
     cntr++;
   }
 }
 
 TEST(Run_Wasm_Return_I64) {
   REQUIRE(I64Return);
   WasmRunner<int64_t> r(MachineType::Int64());
 
-  BUILD(r, WASM_RETURN(WASM_GET_LOCAL(0)));
+  BUILD(r, WASM_RETURN1(WASM_GET_LOCAL(0)));
 
   FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
 }
 
 // todo(ahaas): I added a list of missing instructions here to make merging
 // easier when I do them one by one.
 // kExprI64Add:
 TEST(Run_WasmI64Add) {
   REQUIRE(I64Add);
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
@@ skipping 679 matching lines @@
       continue;
     } else {
       BUILD(t, WASM_GET_LOCAL(i));
     }
     uint32_t index = t.CompileAndAdd();
 
     // Build the calling function.
     WasmRunner<int32_t> r(&module);
     BUILD(
         r,
-        WASM_I32_CONVERT_I64(WASM_CALL_FUNCTION(
-            index, WASM_I64V_9(0xbcd12340000000b),
+        WASM_I32_CONVERT_I64(WASM_CALL_FUNCTIONN(
+            19, index, WASM_I64V_9(0xbcd12340000000b),
             WASM_I64V_9(0xbcd12340000000c), WASM_I32V_1(0xd),
             WASM_I32_CONVERT_I64(WASM_I64V_9(0xbcd12340000000e)),
             WASM_I64V_9(0xbcd12340000000f), WASM_I64V_10(0xbcd1234000000010),
             WASM_I64V_10(0xbcd1234000000011), WASM_I64V_10(0xbcd1234000000012),
             WASM_I64V_10(0xbcd1234000000013), WASM_I64V_10(0xbcd1234000000014),
             WASM_I64V_10(0xbcd1234000000015), WASM_I64V_10(0xbcd1234000000016),
             WASM_I64V_10(0xbcd1234000000017), WASM_I64V_10(0xbcd1234000000018),
             WASM_I64V_10(0xbcd1234000000019), WASM_I64V_10(0xbcd123400000001a),
             WASM_I64V_10(0xbcd123400000001b), WASM_I64V_10(0xbcd123400000001c),
             WASM_I64V_10(0xbcd123400000001d))));
@@ skipping 255 matching lines @@
   REQUIRE(I64Sub);
   // Build the target function.
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.l_ll(), &module);
   BUILD(t, WASM_I64_SUB(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   uint32_t index = t.CompileAndAdd();
 
   // Build the caller function.
   WasmRunner<int64_t> r(&module, MachineType::Int64(), MachineType::Int64());
-  BUILD(r, WASM_CALL_FUNCTION(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
+  BUILD(r, WASM_CALL_FUNCTION2(index, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int64_t a = static_cast<int64_t>(*i) << 32 |
                   (static_cast<int64_t>(*j) | 0xFFFFFFFF);
       int64_t b = static_cast<int64_t>(*j) << 32 |
                   (static_cast<int64_t>(*i) | 0xFFFFFFFF);
 
       int64_t expected = static_cast<int64_t>(static_cast<uint64_t>(a) -
                                               static_cast<uint64_t>(b));
       CHECK_EQ(expected, r.Call(a, b));
     }
   }
 }
 
 TEST(Run_Wasm_LoadStoreI64_sx) {
   REQUIRE(I64LoadStore);
   REQUIRE(DepthFirst);
   byte loads[] = {kExprI64LoadMem8S, kExprI64LoadMem16S, kExprI64LoadMem32S,
                   kExprI64LoadMem};
 
   for (size_t m = 0; m < arraysize(loads); m++) {
     TestingModule module;
     byte* memory = module.AddMemoryElems<byte>(16);
     WasmRunner<int64_t> r(&module);
 
-    byte code[] = {kExprI64StoreMem, ZERO_ALIGNMENT,
-                   ZERO_OFFSET,          // --
-                   kExprI8Const,     8,  // --
-                   loads[m],         ZERO_ALIGNMENT,
-                   ZERO_OFFSET,           // --
-                   kExprI8Const,     0};  // --
+    byte code[] = {
+        kExprI8Const,     8,  // --
+        kExprI8Const,     0,  // --
+        loads[m],             // --
+        ZERO_ALIGNMENT,       // --
+        ZERO_OFFSET,          // --
+        kExprI64StoreMem,     // --
+        ZERO_ALIGNMENT,       // --
+        ZERO_OFFSET           // --
+    };
 
     r.Build(code, code + arraysize(code));
 
     // Try a bunch of different negative values.
     for (int i = -1; i >= -128; i -= 11) {
       int size = 1 << m;
       module.BlankMemory();
       memory[size - 1] = static_cast<byte>(i);  // set the high order byte.
 
       int64_t expected = static_cast<int64_t>(i) << ((size - 1) * 8);
@@ skipping 206 matching lines @@
   WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
   BUILD(r, WASM_I64_ROL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       int64_t expected = bits::RotateLeft64(*i, *j & 0x3f);
       CHECK_EQ(expected, r.Call(*i, *j));
     }
   }
 }