[wasm] Fix more -Wsign-compare warnings.

test/unittests/wasm/decoder-unittest.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 "test/unittests/test-utils.h"
 
 #include "src/objects-inl.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 class DecoderTest : public TestWithZone {
  public:
   DecoderTest() : decoder(nullptr, nullptr) {}
 
   Decoder decoder;
 };
 
-#define CHECK_UINT32V_INLINE(expected, expected_length, ...)           \
-  do {                                                                 \
-    const byte data[] = {__VA_ARGS__};                                 \
-    decoder.Reset(data, data + sizeof(data));                          \
-    unsigned length;                                                   \
-    EXPECT_EQ(expected,                                                \
-              decoder.checked_read_u32v(decoder.start(), 0, &length)); \
-    EXPECT_EQ(expected_length, length);                                \
-    EXPECT_EQ(data, decoder.pc());                                     \
-    EXPECT_TRUE(decoder.ok());                                         \
-    EXPECT_EQ(expected, decoder.consume_u32v());                       \
-    EXPECT_EQ(data + expected_length, decoder.pc());                   \
+#define CHECK_UINT32V_INLINE(expected, expected_length, ...)            \
+  do {                                                                  \
+    const byte data[] = {__VA_ARGS__};                                  \
+    decoder.Reset(data, data + sizeof(data));                           \
+    unsigned length;                                                    \
+    EXPECT_EQ(static_cast<uint32_t>(expected),                          \
+              decoder.checked_read_u32v(decoder.start(), 0, &length));  \
+    EXPECT_EQ(static_cast<unsigned>(expected_length), length);          \
+    EXPECT_EQ(data, decoder.pc());                                      \
+    EXPECT_TRUE(decoder.ok());                                          \
+    EXPECT_EQ(static_cast<uint32_t>(expected), decoder.consume_u32v()); \
+    EXPECT_EQ(data + expected_length, decoder.pc());                    \
   } while (false)
 
 #define CHECK_INT32V_INLINE(expected, expected_length, ...)            \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
     unsigned length;                                                   \
     EXPECT_EQ(expected,                                                \
               decoder.checked_read_i32v(decoder.start(), 0, &length)); \
-    EXPECT_EQ(expected_length, length);                                \
+    EXPECT_EQ(static_cast<unsigned>(expected_length), length);         \
     EXPECT_EQ(data, decoder.pc());                                     \
     EXPECT_TRUE(decoder.ok());                                         \
     EXPECT_EQ(expected, decoder.consume_i32v());                       \
     EXPECT_EQ(data + expected_length, decoder.pc());                   \
   } while (false)
 
 #define CHECK_UINT64V_INLINE(expected, expected_length, ...)           \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
     unsigned length;                                                   \
-    EXPECT_EQ(expected,                                                \
+    EXPECT_EQ(static_cast<uint64_t>(expected),                         \
               decoder.checked_read_u64v(decoder.start(), 0, &length)); \
-    EXPECT_EQ(expected_length, length);                                \
+    EXPECT_EQ(static_cast<unsigned>(expected_length), length);         \
   } while (false)
 
 #define CHECK_INT64V_INLINE(expected, expected_length, ...)            \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
     unsigned length;                                                   \
     EXPECT_EQ(expected,                                                \
               decoder.checked_read_i64v(decoder.start(), 0, &length)); \
-    EXPECT_EQ(expected_length, length);                                \
+    EXPECT_EQ(static_cast<unsigned>(expected_length), length);         \
   } while (false)
 
 TEST_F(DecoderTest, ReadU32v_OneByte) {
   CHECK_UINT32V_INLINE(0, 1, 0);
   CHECK_UINT32V_INLINE(5, 1, 5);
   CHECK_UINT32V_INLINE(7, 1, 7);
   CHECK_UINT32V_INLINE(9, 1, 9);
   CHECK_UINT32V_INLINE(37, 1, 37);
   CHECK_UINT32V_INLINE(69, 1, 69);
   CHECK_UINT32V_INLINE(110, 1, 110);
@@ skipping 292 matching lines @@
   for (int i = max; i > max - 10; i--) {
     CHECK_INT32V_INLINE(i, 5, U32V_5(i));
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end1) {
   static const byte data[] = {U32V_1(11)};
   unsigned length = 0;
   decoder.Reset(data, data);
   decoder.checked_read_u32v(decoder.start(), 0, &length);
-  EXPECT_EQ(0, length);
+  EXPECT_EQ(0u, length);
   EXPECT_FALSE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end2) {
   static const byte data[] = {U32V_2(1111)};
   for (size_t i = 0; i < sizeof(data); i++) {
     unsigned length = 0;
     decoder.Reset(data, data + i);
     decoder.checked_read_u32v(decoder.start(), 0, &length);
     EXPECT_EQ(i, length);
@@ skipping 34 matching lines @@
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_extra_bits) {
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x00};
   for (int i = 1; i < 16; i++) {
     data[4] = static_cast<byte>(i << 4);
     unsigned length = 0;
     decoder.Reset(data, data + sizeof(data));
     decoder.checked_read_u32v(decoder.start(), 0, &length);
-    EXPECT_EQ(5, length);
+    EXPECT_EQ(5u, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadI32v_extra_bits_negative) {
   // OK for negative signed values to have extra ones.
   unsigned length = 0;
   byte data[] = {0xff, 0xff, 0xff, 0xff, 0x7f};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i32v(decoder.start(), 0, &length);
-  EXPECT_EQ(5, length);
+  EXPECT_EQ(5u, length);
   EXPECT_TRUE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadI32v_extra_bits_positive) {
   // Not OK for positive signed values to have extra ones.
   unsigned length = 0;
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x77};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i32v(decoder.start(), 0, &length);
-  EXPECT_EQ(5, length);
+  EXPECT_EQ(5u, length);
   EXPECT_FALSE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadU32v_Bits) {
   // A more exhaustive test.
   const int kMaxSize = 5;
   const uint32_t kVals[] = {
       0xaabbccdd, 0x11223344, 0x33445566, 0xffeeddcc, 0xF0F0F0F0, 0x0F0F0F0F,
       0xEEEEEEEE, 0xAAAAAAAA, 0x12345678, 0x9abcdef0, 0x80309488, 0x729ed997,
       0xc4a0cf81, 0x16c6eb85, 0x4206db8e, 0xf3b089d5, 0xaa2e223e, 0xf99e29c8,
       0x4a4357d8, 0x1890b1c1, 0x8d80a085, 0xacb6ae4c, 0x1b827e10, 0xeb5c7bd9,
       0xbb1bc146, 0xdf57a33l};
   byte data[kMaxSize];
 
   // foreach value in above array
   for (size_t v = 0; v < arraysize(kVals); v++) {
     // foreach length 1...32
     for (int i = 1; i <= 32; i++) {
       uint32_t val = kVals[v];
       if (i < 32) val &= ((1 << i) - 1);
 
-      int length = 1 + i / 7;
-      for (int j = 0; j < kMaxSize; j++) {
+      unsigned length = 1 + i / 7;
+      for (unsigned j = 0; j < kMaxSize; j++) {
         data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
       }
-      for (int j = 0; j < length - 1; j++) {
+      for (unsigned j = 0; j < length - 1; j++) {
         data[j] |= 0x80;
       }
 
       // foreach buffer size 0...5
-      for (int limit = 0; limit <= kMaxSize; limit++) {
+      for (unsigned limit = 0; limit <= kMaxSize; limit++) {
         decoder.Reset(data, data + limit);
         unsigned rlen;
         uint32_t result = decoder.checked_read_u32v(data, 0, &rlen);
         if (limit < length) {
           EXPECT_FALSE(decoder.ok());
         } else {
           EXPECT_TRUE(decoder.ok());
           EXPECT_EQ(val, result);
           EXPECT_EQ(length, rlen);
         }
@@ skipping 29 matching lines @@
   CHECK_INT64V_INLINE(-11, 1, 117);
   CHECK_INT64V_INLINE(-62, 1, 66);
   CHECK_INT64V_INLINE(-63, 1, 65);
   CHECK_INT64V_INLINE(-64, 1, 64);
 }
 
 TEST_F(DecoderTest, ReadU64v_PowerOf2) {
   const int kMaxSize = 10;
   byte data[kMaxSize];
 
-  for (int i = 0; i < 64; i++) {
+  for (unsigned i = 0; i < 64; i++) {
     const uint64_t val = 1ull << i;
-    int index = i / 7;
+    unsigned index = i / 7;
     data[index] = 1 << (i % 7);
     memset(data, 0x80, index);
 
-    for (int limit = 0; limit <= kMaxSize; limit++) {
+    for (unsigned limit = 0; limit <= kMaxSize; limit++) {
       decoder.Reset(data, data + limit);
       unsigned length;
       uint64_t result = decoder.checked_read_u64v(data, 0, &length);
       if (limit <= index) {
         EXPECT_FALSE(decoder.ok());
       } else {
         EXPECT_TRUE(decoder.ok());
         EXPECT_EQ(val, result);
         EXPECT_EQ(index + 1, length);
       }
@@ skipping 11 matching lines @@
       0x8d80a085acb6ae4cull, 0x1b827e10eb5c7bd9ull, 0xbb1bc146df57a338ull};
   byte data[kMaxSize];
 
   // foreach value in above array
   for (size_t v = 0; v < arraysize(kVals); v++) {
     // foreach length 1...64
     for (int i = 1; i <= 64; i++) {
       uint64_t val = kVals[v];
       if (i < 64) val &= ((1ull << i) - 1);
 
-      int length = 1 + i / 7;
-      for (int j = 0; j < kMaxSize; j++) {
+      unsigned length = 1 + i / 7;
+      for (unsigned j = 0; j < kMaxSize; j++) {
         data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
       }
-      for (int j = 0; j < length - 1; j++) {
+      for (unsigned j = 0; j < length - 1; j++) {
         data[j] |= 0x80;
       }
 
       // foreach buffer size 0...10
-      for (int limit = 0; limit <= kMaxSize; limit++) {
+      for (unsigned limit = 0; limit <= kMaxSize; limit++) {
         decoder.Reset(data, data + limit);
         unsigned rlen;
         uint64_t result = decoder.checked_read_u64v(data, 0, &rlen);
         if (limit < length) {
           EXPECT_FALSE(decoder.ok());
         } else {
           EXPECT_TRUE(decoder.ok());
           EXPECT_EQ(val, result);
           EXPECT_EQ(length, rlen);
         }
@@ skipping 12 matching lines @@
       0x4206db8ef3b089d5ull, 0xaa2e223ef99e29c8ull, 0x4a4357d81890b1c1ull,
       0x8d80a085acb6ae4cull, 0x1b827e10eb5c7bd9ull, 0xbb1bc146df57a338ull};
   byte data[kMaxSize];
 
   // foreach value in above array
   for (size_t v = 0; v < arraysize(kVals); v++) {
     // foreach length 1...64
     for (int i = 1; i <= 64; i++) {
       const int64_t val = bit_cast<int64_t>(kVals[v] << (64 - i)) >> (64 - i);
 
-      int length = 1 + i / 7;
-      for (int j = 0; j < kMaxSize; j++) {
+      unsigned length = 1 + i / 7;
+      for (unsigned j = 0; j < kMaxSize; j++) {
         data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
       }
-      for (int j = 0; j < length - 1; j++) {
+      for (unsigned j = 0; j < length - 1; j++) {
         data[j] |= 0x80;
       }
 
       // foreach buffer size 0...10
-      for (int limit = 0; limit <= kMaxSize; limit++) {
+      for (unsigned limit = 0; limit <= kMaxSize; limit++) {
         decoder.Reset(data, data + limit);
         unsigned rlen;
         int64_t result = decoder.checked_read_i64v(data, 0, &rlen);
         if (limit < length) {
           EXPECT_FALSE(decoder.ok());
         } else {
           EXPECT_TRUE(decoder.ok());
           EXPECT_EQ(val, result);
           EXPECT_EQ(length, rlen);
         }
       }
     }
   }
 }
 
 TEST_F(DecoderTest, ReadU64v_extra_bits) {
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00};
   for (int i = 1; i < 128; i++) {
     data[9] = static_cast<byte>(i << 1);
     unsigned length = 0;
     decoder.Reset(data, data + sizeof(data));
     decoder.checked_read_u64v(decoder.start(), 0, &length);
-    EXPECT_EQ(10, length);
+    EXPECT_EQ(10u, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadI64v_extra_bits_negative) {
   // OK for negative signed values to have extra ones.
   unsigned length = 0;
   byte data[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i64v(decoder.start(), 0, &length);
-  EXPECT_EQ(10, length);
+  EXPECT_EQ(10u, length);
   EXPECT_TRUE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadI64v_extra_bits_positive) {
   // Not OK for positive signed values to have extra ones.
   unsigned length = 0;
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x77};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i64v(decoder.start(), 0, &length);
-  EXPECT_EQ(10, length);
+  EXPECT_EQ(10u, length);
   EXPECT_FALSE(decoder.ok());
 }
 
 TEST_F(DecoderTest, FailOnNullData) {
   decoder.Reset(nullptr, 0);
   decoder.checkAvailable(1);
   EXPECT_FALSE(decoder.ok());
   EXPECT_FALSE(decoder.toResult(nullptr).ok());
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8