[wasm] Update {i32,i64}.const to use signed leb128

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/wasm/wasm-macro-gen.h"
 
@@ skipping 42 matching lines @@
     int32_t result = r.Call();
     CHECK_EQ(value, result);
   }
 }
 
 
 TEST(Run_WasmInt32Const) {
   WasmRunner<int32_t> r;
   const int32_t kExpectedValue = 0x11223344;
   // return(kExpectedValue)
-  BUILD(r, WASM_I32(kExpectedValue));
+  BUILD(r, WASM_I32V_5(kExpectedValue));
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
 
 TEST(Run_WasmInt32Const_many) {
   FOR_INT32_INPUTS(i) {
     WasmRunner<int32_t> r;
     const int32_t kExpectedValue = *i;
     // return(kExpectedValue)
-    BUILD(r, WASM_I32(kExpectedValue));
+    BUILD(r, WASM_I32V(kExpectedValue));
     CHECK_EQ(kExpectedValue, r.Call());
   }
 }
 
 
 TEST(Run_WasmMemorySize) {
   TestingModule module;
   WasmRunner<int32_t> r(&module);
   module.AddMemory(1024);
   BUILD(r, kExprMemorySize);
   CHECK_EQ(1024, r.Call());
 }
 
 
 #if WASM_64
 TEST(Run_WasmInt64Const) {
   WasmRunner<int64_t> r;
   const int64_t kExpectedValue = 0x1122334455667788LL;
   // return(kExpectedValue)
-  BUILD(r, WASM_I64(kExpectedValue));
+  BUILD(r, WASM_I64V_9(kExpectedValue));
   CHECK_EQ(kExpectedValue, r.Call());
 }
 
 
 TEST(Run_WasmInt64Const_many) {
   int cntr = 0;
   FOR_INT32_INPUTS(i) {
     WasmRunner<int64_t> r;
     const int64_t kExpectedValue = (static_cast<int64_t>(*i) << 32) | cntr;
     // return(kExpectedValue)
-    BUILD(r, WASM_I64(kExpectedValue));
+    BUILD(r, WASM_I64V(kExpectedValue));
     CHECK_EQ(kExpectedValue, r.Call());
     cntr++;
   }
 }
 #endif
 
 
 TEST(Run_WasmInt32Param0) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // return(local[0])
@@ skipping 70 matching lines @@
   // return int(13.5d + 43.5d)
   BUILD(r, WASM_I32_SCONVERT_F64(WASM_F64_ADD(WASM_F64(13.5), WASM_F64(43.5))));
   CHECK_EQ(57, r.Call());
 }
 
 
 void TestInt32Binop(WasmOpcode opcode, int32_t expected, int32_t a, int32_t b) {
   {
     WasmRunner<int32_t> r;
     // K op K
-    BUILD(r, WASM_BINOP(opcode, WASM_I32(a), WASM_I32(b)));
+    BUILD(r, WASM_BINOP(opcode, WASM_I32V(a), WASM_I32V(b)));
     CHECK_EQ(expected, r.Call());
   }
   {
     WasmRunner<int32_t> r(MachineType::Int32(), MachineType::Int32());
     // a op b
     BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     CHECK_EQ(expected, r.Call(a, b));
   }
 }
 
@@ skipping 27 matching lines @@
   TestInt32Binop(kExprI32GeS, 0, -3, -2);
   TestInt32Binop(kExprI32GtU, 1, -6, 0);
   TestInt32Binop(kExprI32GeU, 1, 0xF0000000, 98978);
 }
 
 
 void TestInt32Unop(WasmOpcode opcode, int32_t expected, int32_t a) {
   {
     WasmRunner<int32_t> r;
     // return op K
-    BUILD(r, WASM_UNOP(opcode, WASM_I32(a)));
+    BUILD(r, WASM_UNOP(opcode, WASM_I32V(a)));
     CHECK_EQ(expected, r.Call());
   }
   {
     WasmRunner<int32_t> r(MachineType::Int32());
     // return op a
     BUILD(r, WASM_UNOP(opcode, WASM_GET_LOCAL(0)));
     CHECK_EQ(expected, r.Call(a));
   }
 }
 
@@ skipping 80 matching lines @@
   TestInt32Unop(kExprI32Popcnt, 19, 0xfedcba09);
 }
 
 
 #if WASM_64
 void TestInt64Binop(WasmOpcode opcode, int64_t expected, int64_t a, int64_t b) {
   if (!WasmOpcodes::IsSupported(opcode)) return;
   {
     WasmRunner<int64_t> r;
     // return K op K
-    BUILD(r, WASM_BINOP(opcode, WASM_I64(a), WASM_I64(b)));
+    BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b)));
     CHECK_EQ(expected, r.Call());
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
     // return a op b
     BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     CHECK_EQ(expected, r.Call(a, b));
   }
 }
 
 
 void TestInt64Cmp(WasmOpcode opcode, int64_t expected, int64_t a, int64_t b) {
   if (!WasmOpcodes::IsSupported(opcode)) return;
   {
     WasmRunner<int32_t> r;
     // return K op K
-    BUILD(r, WASM_BINOP(opcode, WASM_I64(a), WASM_I64(b)));
+    BUILD(r, WASM_BINOP(opcode, WASM_I64V(a), WASM_I64V(b)));
     CHECK_EQ(expected, r.Call());
   }
   {
     WasmRunner<int32_t> r(MachineType::Int64(), MachineType::Int64());
     // return a op b
     BUILD(r, WASM_BINOP(opcode, WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
     CHECK_EQ(expected, r.Call(a, b));
   }
 }
 
@@ skipping 195 matching lines @@
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 
 TEST(Run_WASM_Int32DivU_byzero_const) {
   for (uint32_t denom = 0xfffffffe; denom < 8; denom++) {
     WasmRunner<uint32_t> r(MachineType::Uint32());
-    BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32(denom)));
+    BUILD(r, WASM_I32_DIVU(WASM_GET_LOCAL(0), WASM_I32V_1(denom)));
 
     for (uint32_t val = 0xfffffff0; val < 8; val++) {
       if (denom == 0) {
         CHECK_TRAP(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
@@ skipping 62 matching lines @@
   CHECK_TRAP64(r.Call(as64(-1001), as64(0)));
   CHECK_TRAP64(r.Call(std::numeric_limits<int64_t>::min(), as64(0)));
   CHECK_EQ(std::numeric_limits<int64_t>::min(),
            r.Call(std::numeric_limits<int64_t>::min(), as64(-1)));
 }
 
 
 TEST(Run_WASM_Int64DivS_byzero_const) {
   for (int8_t denom = -2; denom < 8; denom++) {
     WasmRunner<int64_t> r(MachineType::Int64());
-    BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64(denom)));
+    BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
     for (int64_t val = -7; val < 8; val++) {
       if (denom == 0) {
         CHECK_TRAP64(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
 
 
 TEST(Run_WASM_Int64DivU_byzero_const) {
   for (uint64_t denom = 0xfffffffffffffffe; denom < 8; denom++) {
     WasmRunner<uint64_t> r(MachineType::Uint64());
-    BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64(denom)));
+    BUILD(r, WASM_I64_DIVU(WASM_GET_LOCAL(0), WASM_I64V_1(denom)));
 
     for (uint64_t val = 0xfffffffffffffff0; val < 8; val++) {
       if (denom == 0) {
         CHECK_TRAP64(r.Call(val));
       } else {
         CHECK_EQ(val / denom, r.Call(val));
       }
     }
   }
 }
@@ skipping 575 matching lines @@
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.v_v(), &module);
   BUILD(t, kExprNop);
   uint32_t index = t.CompileAndAdd();
 
   const int32_t kExpected = -414444;
   // Build the calling function.
   WasmRunner<int32_t> r;
   r.env()->module = &module;
-  BUILD(r, WASM_BLOCK(2, WASM_CALL_FUNCTION0(index), WASM_I32(kExpected)));
+  BUILD(r, WASM_BLOCK(2, WASM_CALL_FUNCTION0(index), WASM_I32V_3(kExpected)));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
 }
 
 
 TEST(Run_Wasm_VoidReturn2) {
   // We use a wrapper function because WasmRunner<void> does not exist.
   // Build the test function.
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.v_v(), &module);
   BUILD(t, WASM_RETURN0);
   uint32_t index = t.CompileAndAdd();
 
   const int32_t kExpected = -414444;
   // Build the calling function.
   WasmRunner<int32_t> r;
   r.env()->module = &module;
-  BUILD(r, WASM_BLOCK(2, WASM_CALL_FUNCTION0(index), WASM_I32(kExpected)));
+  BUILD(r, WASM_BLOCK(2, WASM_CALL_FUNCTION0(index), WASM_I32V_3(kExpected)));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
 }
 
 
 TEST(Run_Wasm_Block_If_P) {
   WasmRunner<int32_t> r(MachineType::Int32());
   // { if (p0) return 51; return 52; }
   BUILD(r, WASM_BLOCK(2,                                  // --
@@ skipping 340 matching lines @@
 }
 
 
 TEST(Run_Wasm_StoreMemI32_offset) {
   TestingModule module;
   int32_t* memory = module.AddMemoryElems<int32_t>(4);
   WasmRunner<int32_t> r(&module, MachineType::Int32());
   const int32_t kWritten = 0xaabbccdd;
 
   BUILD(r, WASM_STORE_MEM_OFFSET(MachineType::Int32(), 4, WASM_GET_LOCAL(0),
-                                 WASM_I32(kWritten)));
+                                 WASM_I32V_5(kWritten)));
 
   for (int i = 0; i < 2; i++) {
     module.RandomizeMemory(1111);
     memory[0] = 66666666;
     memory[1] = 77777777;
     memory[2] = 88888888;
     memory[3] = 99999999;
     CHECK_EQ(kWritten, r.Call(i * 4));
     CHECK_EQ(66666666, memory[0]);
     CHECK_EQ(i == 0 ? kWritten : 77777777, memory[1]);
@@ skipping 634 matching lines @@
 }
 
 
 #if WASM_64
 // Test the WasmRunner with an Int64 return value and different numbers of
 // Int64 parameters.
 TEST(Run_TestI64WasmRunner) {
   {
     FOR_INT64_INPUTS(i) {
       WasmRunner<int64_t> r;
-      BUILD(r, WASM_I64(*i));
+      BUILD(r, WASM_I64V(*i));
       CHECK_EQ(*i, r.Call());
     }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64());
     BUILD(r, WASM_GET_LOCAL(0));
     FOR_INT64_INPUTS(i) { CHECK_EQ(*i, r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(MachineType::Int64(), MachineType::Int64());
@@ skipping 34 matching lines @@
 }
 #endif
 
 
 TEST(Run_WasmCallEmpty) {
   const int32_t kExpected = -414444;
   // Build the target function.
   TestSignatures sigs;
   TestingModule module;
   WasmFunctionCompiler t(sigs.i_v(), &module);
-  BUILD(t, WASM_I32(kExpected));
+  BUILD(t, WASM_I32V_3(kExpected));
   uint32_t index = t.CompileAndAdd();
 
   // Build the calling function.
   WasmRunner<int32_t> r(&module);
   BUILD(r, WASM_CALL_FUNCTION0(index));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
 }
 
@@ skipping 51 matching lines @@
   const byte kMemOffset = 8;
   const int32_t kElemNum = kMemOffset / sizeof(int32_t);
   const int32_t kExpected = -414444;
   // Build the target function.
   TestSignatures sigs;
   TestingModule module;
   module.AddMemory(16);
   module.RandomizeMemory();
   WasmFunctionCompiler t(sigs.v_v(), &module);
   BUILD(t, WASM_STORE_MEM(MachineType::Int32(), WASM_I8(kMemOffset),
-                          WASM_I32(kExpected)));
+                          WASM_I32V_3(kExpected)));
   uint32_t index = t.CompileAndAdd();
 
   // Build the calling function.
   WasmRunner<int32_t> r(&module);
   BUILD(r, WASM_CALL_FUNCTION0(index),
         WASM_LOAD_MEM(MachineType::Int32(), WASM_I8(kMemOffset)));
 
   int32_t result = r.Call();
   CHECK_EQ(kExpected, result);
   CHECK_EQ(kExpected, module.raw_mem_start<int32_t>()[kElemNum]);
@@ skipping 159 matching lines @@
              static_cast<byte>(WasmOpcodes::LoadStoreOpcodeOf(result, true)),
              WasmOpcodes::LoadStoreAccessOf(false));
     ADD_CODE(code, WASM_ZERO);
     ADD_CODE(code, kExprCallFunction, static_cast<byte>(index));
 
     for (int i = 0; i < num_params; i++) {
       int offset = (i + 1) * kElemSize;
       ADD_CODE(code, WASM_LOAD_MEM(memtypes[i], WASM_I8(offset)));
     }
 
-    ADD_CODE(code, WASM_I32(kExpected));
+    ADD_CODE(code, WASM_I32V_2(kExpected));
     size_t end = code.size();
     code.push_back(0);
     r.Build(&code[0], &code[end]);
 
     // Run the code.
     for (int t = 0; t < 10; t++) {
       module.RandomizeMemory();
       CHECK_EQ(kExpected, r.Call());
 
       int size = WasmOpcodes::MemSize(result);
@@ skipping 544 matching lines @@
     WasmRunner<double> r;
     BUILD(r, WASM_F64_MAX(WASM_F64(45.73),
                           WASM_F64(bit_cast<double>(0x7ff000000000f1e2))));
     CHECK_EQ(0x7ff800000000f1e2, bit_cast<uint64_t>(r.Call()));
   }
 }
 
 #endif
 
 #if WASM_64
+TEST(Run_Wasm_F32SConvertI64) {
+  WasmRunner<float> r(MachineType::Int64());
+  BUILD(r, WASM_F32_SCONVERT_I64(WASM_GET_LOCAL(0)));
+  FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<float>(*i), r.Call(*i)); }
+}
+
+
+#if !defined(_WIN64)
+// TODO(ahaas): Fix this failure.
+TEST(Run_Wasm_F32UConvertI64) {
+  WasmRunner<float> r(MachineType::Uint64());
+  BUILD(r, WASM_F32_UCONVERT_I64(WASM_GET_LOCAL(0)));
+  FOR_UINT64_INPUTS(i) { CHECK_EQ(static_cast<float>(*i), r.Call(*i)); }
+}
+#endif
+
+
+TEST(Run_Wasm_F64SConvertI64) {
+  WasmRunner<double> r(MachineType::Int64());
+  BUILD(r, WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0)));
+  FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<double>(*i), r.Call(*i)); }
+}
+
+
+#if !defined(_WIN64)
+// TODO(ahaas): Fix this failure.
+TEST(Run_Wasm_F64UConvertI64) {
+  WasmRunner<double> r(MachineType::Uint64());
+  BUILD(r, WASM_F64_UCONVERT_I64(WASM_GET_LOCAL(0)));
+  FOR_UINT64_INPUTS(i) { CHECK_EQ(static_cast<double>(*i), r.Call(*i)); }
+}
+#endif
+
+
 TEST(Run_Wasm_I64SConvertF32) {
   WasmRunner<int64_t> r(MachineType::Float32());
   BUILD(r, WASM_I64_SCONVERT_F32(WASM_GET_LOCAL(0)));
 
   FOR_FLOAT32_INPUTS(i) {
     if (*i < static_cast<float>(INT64_MAX) &&
         *i >= static_cast<float>(INT64_MIN)) {
       CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i));
     } else {
       CHECK_TRAP64(r.Call(*i));
@@ skipping 167 matching lines @@
 
 #if WASM_64
 TEST(Compile_Wasm_CallIndirect_Many_i64) { CompileCallIndirectMany(kAstI64); }
 #endif
 
 
 TEST(Compile_Wasm_CallIndirect_Many_f32) { CompileCallIndirectMany(kAstF32); }
 
 
 TEST(Compile_Wasm_CallIndirect_Many_f64) { CompileCallIndirectMany(kAstF64); }