[wasm] Fix more -Wsign-compare warnings.

test/unittests/wasm/ast-decoder-unittest.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 "test/unittests/test-utils.h"
 
 #include "src/v8.h"
 
 #include "test/common/wasm/test-signatures.h"
 
@@ skipping 2228 matching lines @@
       kExprI32Add);
 }
 
 class BranchTableIteratorTest : public TestWithZone {
  public:
   BranchTableIteratorTest() : TestWithZone() {}
   void CheckBrTableSize(const byte* start, const byte* end) {
     Decoder decoder(start, end);
     BranchTableOperand operand(&decoder, start);
     BranchTableIterator iterator(&decoder, operand);
-    EXPECT_EQ(end - start - 1, iterator.length());
+    EXPECT_EQ(end - start - 1u, iterator.length());
     EXPECT_TRUE(decoder.ok());
   }
   void CheckBrTableError(const byte* start, const byte* end) {
     Decoder decoder(start, end);
     BranchTableOperand operand(&decoder, start);
     BranchTableIterator iterator(&decoder, operand);
     iterator.length();
     EXPECT_FALSE(decoder.ok());
   }
 };
@@ skipping 37 matching lines @@
 TEST_F(BranchTableIteratorTest, error0) {
   CHECK_BR_TABLE_ERROR(0);
   CHECK_BR_TABLE_ERROR(1, U32V_1(33));
 }
 
 class WasmOpcodeLengthTest : public TestWithZone {
  public:
   WasmOpcodeLengthTest() : TestWithZone() {}
 };
 
-#define EXPECT_LENGTH(expected, opcode)                           \
-  {                                                               \
-    static const byte code[] = {opcode, 0, 0, 0, 0, 0, 0, 0, 0};  \
-    EXPECT_EQ(expected, OpcodeLength(code, code + sizeof(code))); \
+#define EXPECT_LENGTH(expected, opcode)                          \
+  {                                                              \
+    static const byte code[] = {opcode, 0, 0, 0, 0, 0, 0, 0, 0}; \
+    EXPECT_EQ(static_cast<unsigned>(expected),                   \
+              OpcodeLength(code, code + sizeof(code)));          \
   }
 
-#define EXPECT_LENGTH_N(expected, ...)                            \
-  {                                                               \
-    static const byte code[] = {__VA_ARGS__};                     \
-    EXPECT_EQ(expected, OpcodeLength(code, code + sizeof(code))); \
+#define EXPECT_LENGTH_N(expected, ...)                  \
+  {                                                     \
+    static const byte code[] = {__VA_ARGS__};           \
+    EXPECT_EQ(static_cast<unsigned>(expected),          \
+              OpcodeLength(code, code + sizeof(code))); \
   }
 
 TEST_F(WasmOpcodeLengthTest, Statements) {
   EXPECT_LENGTH(1, kExprNop);
   EXPECT_LENGTH(2, kExprBlock);
   EXPECT_LENGTH(2, kExprLoop);
   EXPECT_LENGTH(2, kExprIf);
   EXPECT_LENGTH(1, kExprElse);
   EXPECT_LENGTH(1, kExprEnd);
   EXPECT_LENGTH(1, kExprSelect);
@@ skipping 237 matching lines @@
   AstLocalDecls decls(zone());
   bool result = DecodeLocalDecls(decls, nullptr, nullptr);
   EXPECT_FALSE(result);
 }
 
 TEST_F(LocalDeclDecoderTest, NoLocals) {
   static const byte data[] = {0};
   AstLocalDecls decls(zone());
   bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
   EXPECT_TRUE(result);
-  EXPECT_EQ(0, decls.total_local_count);
+  EXPECT_EQ(0u, decls.total_local_count);
 }
 
 TEST_F(LocalDeclDecoderTest, OneLocal) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType type = kLocalTypes[i];
     const byte data[] = {
         1, 1, static_cast<byte>(WasmOpcodes::LocalTypeCodeFor(type))};
     AstLocalDecls decls(zone());
     bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
     EXPECT_TRUE(result);
-    EXPECT_EQ(1, decls.total_local_count);
+    EXPECT_EQ(1u, decls.total_local_count);
 
     LocalTypeMap map = Expand(decls);
-    EXPECT_EQ(1, map.size());
+    EXPECT_EQ(1u, map.size());
     EXPECT_EQ(type, map[0]);
   }
 }
 
 TEST_F(LocalDeclDecoderTest, FiveLocals) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalType type = kLocalTypes[i];
     const byte data[] = {
         1, 5, static_cast<byte>(WasmOpcodes::LocalTypeCodeFor(type))};
     AstLocalDecls decls(zone());
     bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
     EXPECT_TRUE(result);
     EXPECT_EQ(sizeof(data), decls.decls_encoded_size);
-    EXPECT_EQ(5, decls.total_local_count);
+    EXPECT_EQ(5u, decls.total_local_count);
 
     LocalTypeMap map = Expand(decls);
-    EXPECT_EQ(5, map.size());
+    EXPECT_EQ(5u, map.size());
     ExpectRun(map, 0, type, 5);
   }
 }
 
 TEST_F(LocalDeclDecoderTest, MixedLocals) {
   for (byte a = 0; a < 3; a++) {
     for (byte b = 0; b < 3; b++) {
       for (byte c = 0; c < 3; c++) {
         for (byte d = 0; d < 3; d++) {
           const byte data[] = {4, a,         kLocalI32, b,        kLocalI64,
                                c, kLocalF32, d,         kLocalF64};
           AstLocalDecls decls(zone());
           bool result = DecodeLocalDecls(decls, data, data + sizeof(data));
           EXPECT_TRUE(result);
           EXPECT_EQ(sizeof(data), decls.decls_encoded_size);
-          EXPECT_EQ(a + b + c + d, decls.total_local_count);
+          EXPECT_EQ(static_cast<uint32_t>(a + b + c + d),
+                    decls.total_local_count);
 
           LocalTypeMap map = Expand(decls);
-          EXPECT_EQ(a + b + c + d, map.size());
+          EXPECT_EQ(static_cast<uint32_t>(a + b + c + d), map.size());
 
           size_t pos = 0;
           pos = ExpectRun(map, pos, kAstI32, a);
           pos = ExpectRun(map, pos, kAstI64, b);
           pos = ExpectRun(map, pos, kAstF32, c);
           pos = ExpectRun(map, pos, kAstF64, d);
         }
       }
     }
   }
 }
 
 TEST_F(LocalDeclDecoderTest, UseEncoder) {
   const byte* data = nullptr;
   const byte* end = nullptr;
   LocalDeclEncoder local_decls(zone());
 
   local_decls.AddLocals(5, kAstF32);
   local_decls.AddLocals(1337, kAstI32);
   local_decls.AddLocals(212, kAstI64);
   local_decls.Prepend(zone(), &data, &end);
 
   AstLocalDecls decls(zone());
   bool result = DecodeLocalDecls(decls, data, end);
   EXPECT_TRUE(result);
-  EXPECT_EQ(5 + 1337 + 212, decls.total_local_count);
+  EXPECT_EQ(5u + 1337u + 212u, decls.total_local_count);
 
   LocalTypeMap map = Expand(decls);
   size_t pos = 0;
   pos = ExpectRun(map, pos, kAstF32, 5);
   pos = ExpectRun(map, pos, kAstI32, 1337);
   pos = ExpectRun(map, pos, kAstI64, 212);
 }
 
 class BytecodeIteratorTest : public TestWithZone {};
 
@@ skipping 31 matching lines @@
     count++;
   }
   EXPECT_EQ(6, count);
 }
 
 TEST_F(BytecodeIteratorTest, WithAstDecls) {
   byte code[] = {1, 1, kLocalI32, WASM_I8(9), WASM_I8(11)};
   AstLocalDecls decls(zone());
   BytecodeIterator iter(code, code + sizeof(code), &decls);
 
-  EXPECT_EQ(3, decls.decls_encoded_size);
-  EXPECT_EQ(3, iter.pc_offset());
+  EXPECT_EQ(3u, decls.decls_encoded_size);
+  EXPECT_EQ(3u, iter.pc_offset());
   EXPECT_TRUE(iter.has_next());
   EXPECT_EQ(kExprI8Const, iter.current());
   iter.next();
   EXPECT_TRUE(iter.has_next());
   EXPECT_EQ(kExprI8Const, iter.current());
   iter.next();
   EXPECT_FALSE(iter.has_next());
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8