[wasm] Fix -Wsign-compare warnings.

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"
@@ skipping 180 matching lines @@
 
 WASM_EXEC_TEST(I64ShlUseOnlyLowWord) {
   REQUIRE(I64Shl);
   REQUIRE(I32ConvertI64);
   WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
                         MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       uint64_t expected = static_cast<int32_t>((*i) << (*j & 0x3f));

[ahaas, 2016/11/10 09:03:39]

Can you change the type of {expected} to int32_t instead of doing the
static_cast below?

[ulan, 2016/11/10 12:23:43]

Done.

-      CHECK_EQ(expected, r.Call(*i, *j));
+      CHECK_EQ(static_cast<int64_t>(expected), r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64ShrUseOnlyLowWord) {
   REQUIRE(I64ShrU);
   REQUIRE(I32ConvertI64);
   WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
                         MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
       uint64_t expected = static_cast<int32_t>((*i) >> (*j & 0x3f));

[ahaas, 2016/11/10 09:03:39]

Can you change the type of {expected} to int32_t instead of doing the
static_cast below?

[ulan, 2016/11/10 12:23:43]

Done.

-      CHECK_EQ(expected, r.Call(*i, *j));
+      CHECK_EQ(static_cast<int64_t>(expected), r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64SarUseOnlyLowWord) {
   REQUIRE(I64ShrS);
   REQUIRE(I32ConvertI64);
   WasmRunner<int32_t> r(execution_mode, MachineType::Int64(),
                         MachineType::Int64());
   BUILD(r, WASM_I32_CONVERT_I64(
                WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))));
   FOR_INT64_INPUTS(i) {
     FOR_INT64_INPUTS(j) {
       uint64_t expected = static_cast<int32_t>((*i) >> (*j & 0x3f));

[ahaas, 2016/11/10 09:03:39]

Can you change the type of {expected} to int32_t instead of doing the
static_cast below?

[ulan, 2016/11/10 12:23:42]

Done.

-      CHECK_EQ(expected, r.Call(*i, *j));
+      CHECK_EQ(static_cast<int64_t>(expected), r.Call(*i, *j));
     }
   }
 }
 
 WASM_EXEC_TEST(I64DivS) {
   REQUIRE(I64DivS);
   WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
                         MachineType::Int64());
   BUILD(r, WASM_I64_DIVS(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
   FOR_INT64_INPUTS(i) {
@@ skipping 172 matching lines @@
     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
     FOR_UINT64_INPUTS(i) {
       FOR_UINT64_INPUTS(j) {
         uint64_t expected = (*i) << (*j & 0x3f);
         CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:43]

Done.

     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 0, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i << 0), r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:42]

Done.

     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 32, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i << 32), r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:43]

Done.

     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 20, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i << 20), r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:43]

Done.

     BUILD(r, WASM_I64_SHL(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i << 40, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i << 40), r.Call(*i)); }
   }
 }
 
 WASM_EXEC_TEST(I64ShrU) {
   REQUIRE(I64ShrU);
   {
     WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64(),
                            MachineType::Uint64());
     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
     FOR_UINT64_INPUTS(i) {
       FOR_UINT64_INPUTS(j) {
         uint64_t expected = (*i) >> (*j & 0x3f);
         CHECK_EQ(expected, r.Call(*i, *j));
       }
     }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:42]

Done.

     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(0)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 0, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i >> 0), r.Call(*i)); }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:42]

Done.

     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(32)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 32, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) {
+      CHECK_EQ(static_cast<int64_t>(*i >> 32), r.Call(*i));
+    }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:43]

Done.

     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(20)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 20, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) {
+      CHECK_EQ(static_cast<int64_t>(*i >> 20), r.Call(*i));
+    }
   }
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64());

[ahaas, 2016/11/10 09:03:39]

Can you change
WasmRunner<int64_t> r(execution_mode, MachineType::Int64());
to
WasmRunner<uint64_t> r(execution_mode, MachineType::Uint64());
here instead of the bitcast below?

[ulan, 2016/11/10 12:23:43]

Done.

     BUILD(r, WASM_I64_SHR(WASM_GET_LOCAL(0), WASM_I64V_1(40)));
-    FOR_UINT64_INPUTS(i) { CHECK_EQ(*i >> 40, r.Call(*i)); }
+    FOR_UINT64_INPUTS(i) {
+      CHECK_EQ(static_cast<int64_t>(*i >> 40), r.Call(*i));
+    }
   }
 }
 
 WASM_EXEC_TEST(I64ShrS) {
   REQUIRE(I64ShrS);
   {
     WasmRunner<int64_t> r(execution_mode, MachineType::Int64(),
                           MachineType::Int64());
     BUILD(r, WASM_I64_SAR(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1)));
 
@@ skipping 139 matching lines @@
   REQUIRE(I64SConvertI32);
   WasmRunner<int64_t> r(execution_mode, MachineType::Int32());
   BUILD(r, WASM_I64_SCONVERT_I32(WASM_GET_LOCAL(0)));
   FOR_INT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(I64UConvertI32) {
   REQUIRE(I64UConvertI32);
   WasmRunner<int64_t> r(execution_mode, MachineType::Uint32());
   BUILD(r, WASM_I64_UCONVERT_I32(WASM_GET_LOCAL(0)));
-  FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<uint64_t>(*i), r.Call(*i)); }
+  FOR_UINT32_INPUTS(i) { CHECK_EQ(static_cast<int64_t>(*i), r.Call(*i)); }
 }
 
 WASM_EXEC_TEST(I64Popcnt) {
   struct {
     int64_t expected;
     uint64_t input;
   } values[] = {{64, 0xffffffffffffffff},
                 {0, 0x0000000000000000},
                 {2, 0x0000080000008000},
                 {26, 0x1123456782345678},
@@ skipping 710 matching lines @@
 
 WASM_EXEC_TEST(LoadMemI64) {
   REQUIRE(I64LoadStore);
   TestingModule module(execution_mode);
   int64_t* memory = module.AddMemoryElems<int64_t>(8);
   module.RandomizeMemory(1111);
   WasmRunner<int64_t> r(&module);
 
   BUILD(r, WASM_LOAD_MEM(MachineType::Int64(), WASM_I8(0)));
 
   module.WriteMemory<int64_t>(&memory[0], 0xaabbccdd00112233LL);

[ahaas, 2016/11/10 09:03:39]

I think you could just change 0xaabbccdd00112233LL to 0x1abbccdd00112233LL to
avoid the sign bit.

[ulan, 2016/11/10 12:23:43]

Done.

-  CHECK_EQ(0xaabbccdd00112233LL, r.Call());
+  CHECK_EQ(bit_cast<int64_t>(0xaabbccdd00112233LL), r.Call());
 
   module.WriteMemory<int64_t>(&memory[0], 0x33aabbccdd001122LL);
   CHECK_EQ(0x33aabbccdd001122LL, r.Call());
 
   module.WriteMemory<int64_t>(&memory[0], 77777777);
   CHECK_EQ(77777777, r.Call());
 }
 
 WASM_EXEC_TEST(LoadMemI64_alignment) {
   REQUIRE(I64LoadStore);
   TestingModule module(execution_mode);
   int64_t* memory = module.AddMemoryElems<int64_t>(8);
   for (byte alignment = 0; alignment <= 3; alignment++) {
     module.RandomizeMemory(1111);
     WasmRunner<int64_t> r(&module);
 
     BUILD(r,
           WASM_LOAD_MEM_ALIGNMENT(MachineType::Int64(), WASM_I8(0), alignment));
 
     module.WriteMemory<int64_t>(&memory[0], 0xaabbccdd00112233LL);

[ahaas, 2016/11/10 09:03:39]

same here.

[ulan, 2016/11/10 12:23:43]

Done.

-    CHECK_EQ(0xaabbccdd00112233LL, r.Call());
+    CHECK_EQ(bit_cast<int64_t>(0xaabbccdd00112233LL), r.Call());
 
     module.WriteMemory<int64_t>(&memory[0], 0x33aabbccdd001122LL);
     CHECK_EQ(0x33aabbccdd001122LL, r.Call());
 
     module.WriteMemory<int64_t>(&memory[0], 77777777);
     CHECK_EQ(77777777, r.Call());
   }
 }
 
 WASM_EXEC_TEST(MemI64_Sum) {
@@ skipping 252 matching lines @@
         CHECK_EQ(expected, result);
       }
     }
   }
 }
 
 WASM_EXEC_TEST(MixedCall_i64_0) { Run_WasmMixedCall_N(execution_mode, 0); }
 WASM_EXEC_TEST(MixedCall_i64_1) { Run_WasmMixedCall_N(execution_mode, 1); }
 WASM_EXEC_TEST(MixedCall_i64_2) { Run_WasmMixedCall_N(execution_mode, 2); }
 WASM_EXEC_TEST(MixedCall_i64_3) { Run_WasmMixedCall_N(execution_mode, 3); }