[turbofan] Fix -Wsign-compare warnings.

test/cctest/compiler/test-run-machops.cc

 // Copyright 2014 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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/ieee754.h"
@@ skipping 4153 matching lines @@
 TEST(RunInt32PairAddUseOnlyHighWord) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
       MachineType::Uint32());
 
   m.Return(m.Projection(1, m.Int32PairAdd(m.Parameter(0), m.Parameter(1),
                                           m.Parameter(2), m.Parameter(3))));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
-      CHECK_EQ(static_cast<uint32_t>((*i + *j) >> 32),
-               m.Call(static_cast<uint32_t>(*i & 0xffffffff),
-                      static_cast<uint32_t>(*i >> 32),
-                      static_cast<uint32_t>(*j & 0xffffffff),
-                      static_cast<uint32_t>(*j >> 32)));
+      CHECK_EQ(
+          static_cast<uint32_t>((*i + *j) >> 32),
+          static_cast<uint32_t>(m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+                                       static_cast<uint32_t>(*i >> 32),
+                                       static_cast<uint32_t>(*j & 0xffffffff),
+                                       static_cast<uint32_t>(*j >> 32))));
     }
   }
 }
 
 void TestInt32PairAddWithSharedInput(int a, int b, int c, int d) {
   BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
                                                MachineType::Uint32());
 
   uint32_t high;
   uint32_t low;
@@ skipping 57 matching lines @@
 TEST(RunInt32PairSubUseOnlyHighWord) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
       MachineType::Uint32());
 
   m.Return(m.Projection(1, m.Int32PairSub(m.Parameter(0), m.Parameter(1),
                                           m.Parameter(2), m.Parameter(3))));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
-      CHECK_EQ(static_cast<uint32_t>((*i - *j) >> 32),
-               m.Call(static_cast<uint32_t>(*i & 0xffffffff),
-                      static_cast<uint32_t>(*i >> 32),
-                      static_cast<uint32_t>(*j & 0xffffffff),
-                      static_cast<uint32_t>(*j >> 32)));
+      CHECK_EQ(
+          static_cast<uint32_t>((*i - *j) >> 32),
+          static_cast<uint32_t>(m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+                                       static_cast<uint32_t>(*i >> 32),
+                                       static_cast<uint32_t>(*j & 0xffffffff),
+                                       static_cast<uint32_t>(*j >> 32))));
     }
   }
 }
 
 void TestInt32PairSubWithSharedInput(int a, int b, int c, int d) {
   BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
                                                MachineType::Uint32());
 
   uint32_t high;
   uint32_t low;
@@ skipping 57 matching lines @@
 TEST(RunInt32PairMulUseOnlyHighWord) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
       MachineType::Uint32());
 
   m.Return(m.Projection(1, m.Int32PairMul(m.Parameter(0), m.Parameter(1),
                                           m.Parameter(2), m.Parameter(3))));
 
   FOR_UINT64_INPUTS(i) {
     FOR_UINT64_INPUTS(j) {
-      CHECK_EQ(static_cast<uint32_t>((*i * *j) >> 32),
-               m.Call(static_cast<uint32_t>(*i & 0xffffffff),
-                      static_cast<uint32_t>(*i >> 32),
-                      static_cast<uint32_t>(*j & 0xffffffff),
-                      static_cast<uint32_t>(*j >> 32)));
+      CHECK_EQ(
+          static_cast<uint32_t>((*i * *j) >> 32),
+          static_cast<uint32_t>(m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+                                       static_cast<uint32_t>(*i >> 32),
+                                       static_cast<uint32_t>(*j & 0xffffffff),
+                                       static_cast<uint32_t>(*j >> 32))));
     }
   }
 }
 
 void TestInt32PairMulWithSharedInput(int a, int b, int c, int d) {
   BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
                                                MachineType::Uint32());
 
   uint32_t high;
   uint32_t low;
@@ skipping 54 matching lines @@
 
 TEST(RunWord32PairShlUseOnlyHighWord) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
 
   m.Return(m.Projection(
       1, m.Word32PairShl(m.Parameter(0), m.Parameter(1), m.Parameter(2))));
 
   FOR_UINT64_INPUTS(i) {
     for (uint32_t j = 0; j < 64; j++) {
-      CHECK_EQ(static_cast<uint32_t>((*i << j) >> 32),
-               m.Call(static_cast<uint32_t>(*i & 0xffffffff),
-                      static_cast<uint32_t>(*i >> 32), j));
+      CHECK_EQ(
+          static_cast<uint32_t>((*i << j) >> 32),
+          static_cast<uint32_t>(m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+                                       static_cast<uint32_t>(*i >> 32), j)));
     }
   }
 }
 
 void TestWord32PairShlWithSharedInput(int a, int b) {
   BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
                                                MachineType::Uint32());
 
   uint32_t high;
   uint32_t low;
@@ skipping 50 matching lines @@
 
 TEST(RunWord32PairShrUseOnlyHighWord) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
 
   m.Return(m.Projection(
       1, m.Word32PairShr(m.Parameter(0), m.Parameter(1), m.Parameter(2))));
 
   FOR_UINT64_INPUTS(i) {
     for (uint32_t j = 0; j < 64; j++) {
-      CHECK_EQ(static_cast<uint32_t>((*i >> j) >> 32),
-               m.Call(static_cast<uint32_t>(*i & 0xffffffff),
-                      static_cast<uint32_t>(*i >> 32), j));
+      CHECK_EQ(
+          static_cast<uint32_t>((*i >> j) >> 32),
+          static_cast<uint32_t>(m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+                                       static_cast<uint32_t>(*i >> 32), j)));
     }
   }
 }
 
 TEST(RunWord32PairSar) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
 
   uint32_t high;
   uint32_t low;
 
   Node* PairAdd =
       m.Word32PairSar(m.Parameter(0), m.Parameter(1), m.Parameter(2));
 
   m.StoreToPointer(&low, MachineRepresentation::kWord32,
                    m.Projection(0, PairAdd));
   m.StoreToPointer(&high, MachineRepresentation::kWord32,
                    m.Projection(1, PairAdd));
   m.Return(m.Int32Constant(74));
 
   FOR_INT64_INPUTS(i) {
     for (uint32_t j = 0; j < 64; j++) {
       m.Call(static_cast<uint32_t>(*i & 0xffffffff),
              static_cast<uint32_t>(*i >> 32), j);
-      CHECK_EQ(*i >> j, ToInt64(low, high));
+      CHECK_EQ(*i >> j, static_cast<int64_t>(ToInt64(low, high)));
     }
   }
 }
 
 TEST(RunWord32PairSarUseOnlyHighWord) {
   BufferedRawMachineAssemblerTester<int32_t> m(
       MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
 
   m.Return(m.Projection(
       1, m.Word32PairSar(m.Parameter(0), m.Parameter(1), m.Parameter(2))));
 
   FOR_INT64_INPUTS(i) {
     for (uint32_t j = 0; j < 64; j++) {
-      CHECK_EQ(static_cast<uint32_t>((*i >> j) >> 32),
-               m.Call(static_cast<uint32_t>(*i & 0xffffffff),
-                      static_cast<uint32_t>(*i >> 32), j));
+      CHECK_EQ(
+          static_cast<uint32_t>((*i >> j) >> 32),
+          static_cast<uint32_t>(m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+                                       static_cast<uint32_t>(*i >> 32), j)));
     }
   }
 }
 #endif
 
 TEST(RunDeadChangeFloat64ToInt32) {
   RawMachineAssemblerTester<int32_t> m;
   const int magic = 0x88abcda4;
   m.ChangeFloat64ToInt32(m.Float64Constant(999.78));
   m.Return(m.Int32Constant(magic));
@@ skipping 2131 matching lines @@
   r.Goto(&merge);
   r.Bind(&merge);
   Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb);
   r.Return(phi);
   CHECK_EQ(1, r.Call(1));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8