[turbofan] Fix more -Wsign-compare warnings.

test/cctest/compiler/test-run-load-store.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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 260 matching lines @@
   }
 }
 
 template <typename CType>
 void RunUnalignedLoadStoreUnalignedAccess(MachineType rep) {
   CType in, out;
   CType in_buffer[2];
   CType out_buffer[2];
   byte* raw;
 
-  for (int x = 0; x < sizeof(CType); x++) {
+  for (int x = 0; x < static_cast<int>(sizeof(CType)); x++) {
     int y = sizeof(CType) - x;
 
     raw = reinterpret_cast<byte*>(&in);
     for (size_t i = 0; i < sizeof(CType); i++) {
       raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
     }
 
     raw = reinterpret_cast<byte*>(in_buffer);
     MemCopy(raw + x, &in, sizeof(CType));
 
@@ skipping 224 matching lines @@
     CHECK_EQ(static_cast<int8_t>(*i & 0xff), buffer[1]);
     CHECK_EQ(static_cast<int16_t>(*i & 0xffff), buffer[2]);
     CHECK_EQ(static_cast<int32_t>(*i & 0xffffffff), buffer[3]);
     CHECK_EQ(*i, buffer[4]);
   }
 }
 
 void RunLoadStoreZeroExtend64(TestAlignment t) {
   if (kPointerSize < 8) return;
   uint64_t buffer[5];
-  RawMachineAssemblerTester<int64_t> m;
+  RawMachineAssemblerTester<uint64_t> m;
   Node* load8 = m.LoadFromPointer(LSB(&buffer[0], 1), MachineType::Uint8());
   if (t == TestAlignment::kAligned) {
     Node* load16 = m.LoadFromPointer(LSB(&buffer[0], 2), MachineType::Uint16());
     Node* load32 = m.LoadFromPointer(LSB(&buffer[0], 4), MachineType::Uint32());
     Node* load64 = m.LoadFromPointer(&buffer[0], MachineType::Uint64());
     m.StoreToPointer(&buffer[1], MachineRepresentation::kWord64, load8);
     m.StoreToPointer(&buffer[2], MachineRepresentation::kWord64, load16);
     m.StoreToPointer(&buffer[3], MachineRepresentation::kWord64, load32);
     m.StoreToPointer(&buffer[4], MachineRepresentation::kWord64, load64);
   } else if (t == TestAlignment::kUnaligned) {
@@ skipping 546 matching lines @@
 
   // in-bounds accesses.
   for (uint32_t i = 0; i < kNumElems; i++) {
     uint32_t offset = static_cast<uint32_t>(i * sizeof(MemType));
     MemType expected = buffer[i];
     CHECK_EQ(kReturn, m.Call(offset + pseudo_base, kLength));
     CHECK_EQ(expected, result);
   }
 
   // slightly out-of-bounds accesses.
-  for (int32_t i = kNumElems; i < kNumElems + 30; i++) {
+  for (uint32_t i = kNumElems; i < kNumElems + 30; i++) {
     uint32_t offset = static_cast<uint32_t>(i * sizeof(MemType));
     CHECK_EQ(kReturn, m.Call(offset + pseudo_base, kLength));
     CheckOobValue(result);
   }
 
   // way out-of-bounds accesses.
   for (uint64_t i = pseudo_base + sizeof(buffer); i < 0xFFFFFFFF;
        i += A_BILLION) {
     uint32_t offset = static_cast<uint32_t>(i);
     CHECK_EQ(kReturn, m.Call(offset, kLength));
@@ skipping 78 matching lines @@
   TestRunOobCheckedLoadT_pseudo<int32_t>(4 * A_BILLION, true);
   TestRunOobCheckedLoadT_pseudo<float>(4 * A_BILLION, false);
   TestRunOobCheckedLoadT_pseudo<float>(4 * A_BILLION, true);
   TestRunOobCheckedLoadT_pseudo<double>(4 * A_BILLION, false);
   TestRunOobCheckedLoadT_pseudo<double>(4 * A_BILLION, true);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8