[turbofan] Fix more -Wsign-compare warnings.

BUG=v8:5614

Review-Url: https://codereview.chromium.org/2493173002
Cr-Commit-Position: refs/heads/master@{#40916}

src/arm/assembler-arm.cc

@@ -4280,10 +4280,10 @@ void Assembler::CheckConstPool(bool force_emit, bool require_jump) {
 
   // Deduplicate constants.
   int size_after_marker = estimated_size_after_marker;
-  for (int i = 0; i < pending_64_bit_constants_.size(); i++) {
+  for (size_t i = 0; i < pending_64_bit_constants_.size(); i++) {
     ConstantPoolEntry& entry = pending_64_bit_constants_[i];
     DCHECK(!entry.is_merged());
-    for (int j = 0; j < i; j++) {
+    for (size_t j = 0; j < i; j++) {
       if (entry.value64() == pending_64_bit_constants_[j].value64()) {
         DCHECK(!pending_64_bit_constants_[j].is_merged());
         entry.set_merged_index(j);
@@ -4293,11 +4293,11 @@ void Assembler::CheckConstPool(bool force_emit, bool require_jump) {
     }
   }
 
-  for (int i = 0; i < pending_32_bit_constants_.size(); i++) {
+  for (size_t i = 0; i < pending_32_bit_constants_.size(); i++) {
     ConstantPoolEntry& entry = pending_32_bit_constants_[i];
     DCHECK(!entry.is_merged());
     if (!entry.sharing_ok()) continue;
-    for (int j = 0; j < i; j++) {
+    for (size_t j = 0; j < i; j++) {
       if (entry.value() == pending_32_bit_constants_[j].value()) {
         DCHECK(!pending_32_bit_constants_[j].is_merged());
         entry.set_merged_index(j);
@@ -4338,7 +4338,7 @@ void Assembler::CheckConstPool(bool force_emit, bool require_jump) {
 
     // Emit 64-bit constant pool entries first: their range is smaller than
     // 32-bit entries.
-    for (int i = 0; i < pending_64_bit_constants_.size(); i++) {
+    for (size_t i = 0; i < pending_64_bit_constants_.size(); i++) {
       ConstantPoolEntry& entry = pending_64_bit_constants_[i];
 
       Instr instr = instr_at(entry.position());
@@ -4367,7 +4367,7 @@ void Assembler::CheckConstPool(bool force_emit, bool require_jump) {
     }
 
     // Emit 32-bit constant pool entries.
-    for (int i = 0; i < pending_32_bit_constants_.size(); i++) {
+    for (size_t i = 0; i < pending_32_bit_constants_.size(); i++) {
       ConstantPoolEntry& entry = pending_32_bit_constants_[i];
       Instr instr = instr_at(entry.position());
 

src/arm/assembler-arm.h

@@ -1585,7 +1585,8 @@ class Assembler : public AssemblerBase {
       // Check the constant pool hasn't been blocked for too long.
       DCHECK(pending_32_bit_constants_.empty() ||
              (start + pending_64_bit_constants_.size() * kDoubleSize <
-              (first_const_pool_32_use_ + kMaxDistToIntPool)));
+              static_cast<size_t>(first_const_pool_32_use_ +
+                                  kMaxDistToIntPool)));
       DCHECK(pending_64_bit_constants_.empty() ||
              (start < (first_const_pool_64_use_ + kMaxDistToFPPool)));
 #endif

src/arm/deoptimizer-arm.cc

@@ -329,7 +329,7 @@ void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
     // in a separate table if necessary.
     Label high_fixes[256];
     int high_fix_max = (count() - 1) >> 8;
-    DCHECK_GT(arraysize(high_fixes), high_fix_max);
+    DCHECK_GT(arraysize(high_fixes), static_cast<size_t>(high_fix_max));
     for (int i = 0; i < count(); i++) {
       int start = masm()->pc_offset();
       USE(start);

src/arm/macro-assembler-arm.cc

@@ -663,7 +663,7 @@ void MacroAssembler::RecordWriteCodeEntryField(Register js_function,
 
   // Save caller-saved registers, which includes js_function.
   DCHECK((kCallerSaved & js_function.bit()) != 0);
-  DCHECK_EQ(kCallerSaved & code_entry.bit(), 0);
+  DCHECK_EQ(kCallerSaved & code_entry.bit(), 0u);
   stm(db_w, sp, (kCallerSaved | lr.bit()));
 
   int argument_count = 3;

src/code-stub-assembler.cc

@@ -5428,13 +5428,13 @@ void CodeStubAssembler::EmitElementLoad(Node* object, Node* elements,
         UINT8_ELEMENTS,  UINT8_CLAMPED_ELEMENTS, INT8_ELEMENTS,
         UINT16_ELEMENTS, INT16_ELEMENTS,         UINT32_ELEMENTS,
         INT32_ELEMENTS,  FLOAT32_ELEMENTS,       FLOAT64_ELEMENTS};
-    const int kTypedElementsKindCount = LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND -
-                                        FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND +
-                                        1;
+    const size_t kTypedElementsKindCount =
+        LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND -
+        FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND + 1;
     DCHECK_EQ(kTypedElementsKindCount, arraysize(elements_kinds));
     DCHECK_EQ(kTypedElementsKindCount, arraysize(elements_kind_labels));
     Switch(elements_kind, miss, elements_kinds, elements_kind_labels,
-           static_cast<size_t>(kTypedElementsKindCount));
+           kTypedElementsKindCount);
     Bind(&uint8_elements);
     {
       Comment("UINT8_ELEMENTS");  // Handles UINT8_CLAMPED_ELEMENTS too.

src/compiler/arm/unwinding-info-writer-arm.cc

@@ -15,7 +15,8 @@ void UnwindingInfoWriter::BeginInstructionBlock(int pc_offset,
 
   block_will_exit_ = false;
 
-  DCHECK_LT(block->rpo_number().ToInt(), block_initial_states_.size());
+  DCHECK_LT(block->rpo_number().ToInt(),
+            static_cast<int>(block_initial_states_.size()));
   const BlockInitialState* initial_state =
       block_initial_states_[block->rpo_number().ToInt()];
   if (initial_state) {
@@ -42,7 +43,7 @@ void UnwindingInfoWriter::EndInstructionBlock(const InstructionBlock* block) {
 
   for (const RpoNumber& successor : block->successors()) {
     int successor_index = successor.ToInt();
-    DCHECK_LT(successor_index, block_initial_states_.size());
+    DCHECK_LT(successor_index, static_cast<int>(block_initial_states_.size()));
     const BlockInitialState* existing_state =
         block_initial_states_[successor_index];
 

src/compiler/arm64/unwinding-info-writer-arm64.cc

@@ -15,7 +15,8 @@ void UnwindingInfoWriter::BeginInstructionBlock(int pc_offset,
 
   block_will_exit_ = false;
 
-  DCHECK_LT(block->rpo_number().ToInt(), block_initial_states_.size());
+  DCHECK_LT(block->rpo_number().ToInt(),
+            static_cast<int>(block_initial_states_.size()));
   const BlockInitialState* initial_state =
       block_initial_states_[block->rpo_number().ToInt()];
   if (initial_state) {
@@ -42,7 +43,7 @@ void UnwindingInfoWriter::EndInstructionBlock(const InstructionBlock* block) {
 
   for (const RpoNumber& successor : block->successors()) {
     int successor_index = successor.ToInt();
-    DCHECK_LT(successor_index, block_initial_states_.size());
+    DCHECK_LT(successor_index, static_cast<int>(block_initial_states_.size()));
     const BlockInitialState* existing_state =
         block_initial_states_[successor_index];
 

src/compiler/effect-control-linearizer.cc

@@ -74,7 +74,8 @@ void UpdateEffectPhi(Node* node, BasicBlock* block,
   // Update all inputs to an effect phi with the effects from the given
   // block->effect map.
   DCHECK_EQ(IrOpcode::kEffectPhi, node->opcode());
-  DCHECK_EQ(node->op()->EffectInputCount(), block->PredecessorCount());
+  DCHECK_EQ(static_cast<size_t>(node->op()->EffectInputCount()),
+            block->PredecessorCount());
   for (int i = 0; i < node->op()->EffectInputCount(); i++) {
     Node* input = node->InputAt(i);
     BasicBlock* predecessor = block->PredecessorAt(static_cast<size_t>(i));
@@ -248,7 +249,7 @@ void TryCloneBranch(Node* node, BasicBlock* block, Graph* graph,
     merge_true->AppendInput(graph->zone(), merge_true_inputs[i]);
     merge_false->AppendInput(graph->zone(), merge_false_inputs[i]);
   }
-  DCHECK_EQ(2, block->SuccessorCount());
+  DCHECK_EQ(2u, block->SuccessorCount());
   NodeProperties::ChangeOp(matcher.IfTrue(), common->Merge(input_count));
   NodeProperties::ChangeOp(matcher.IfFalse(), common->Merge(input_count));
   int const true_index =

src/compiler/js-inlining-heuristic.cc

@@ -23,7 +23,7 @@ namespace {
 
 int CollectFunctions(Node* node, Handle<JSFunction>* functions,
                      int functions_size) {
-  DCHECK_NE(0u, functions_size);
+  DCHECK_NE(0, functions_size);
   HeapObjectMatcher m(node);
   if (m.HasValue() && m.Value()->IsJSFunction()) {
     functions[0] = Handle<JSFunction>::cast(m.Value());

src/compiler/pipeline.cc

@@ -274,8 +274,8 @@ class PipelineData {
     if (descriptor && descriptor->RequiresFrameAsIncoming()) {
       sequence_->instruction_blocks()[0]->mark_needs_frame();
     } else {
-      DCHECK_EQ(0, descriptor->CalleeSavedFPRegisters());
-      DCHECK_EQ(0, descriptor->CalleeSavedRegisters());
+      DCHECK_EQ(0u, descriptor->CalleeSavedFPRegisters());
+      DCHECK_EQ(0u, descriptor->CalleeSavedRegisters());
     }
   }
 

src/compiler/x64/code-generator-x64.cc

@@ -447,7 +447,7 @@ class WasmOutOfLineTrap final : public OutOfLineCode {
     OutOfLineCode* ool;                                                      \
     if (instr->InputAt(3)->IsRegister()) {                                   \
       auto length = i.InputRegister(3);                                      \
-      DCHECK_EQ(0, index2);                                                  \
+      DCHECK_EQ(0u, index2);                                                 \
       __ cmpl(index1, length);                                               \
       ool = new (zone()) OutOfLineLoadNaN(this, result);                     \
     } else {                                                                 \
@@ -502,7 +502,7 @@ class WasmOutOfLineTrap final : public OutOfLineCode {
     OutOfLineCode* ool;                                                        \
     if (instr->InputAt(3)->IsRegister()) {                                     \
       auto length = i.InputRegister(3);                                        \
-      DCHECK_EQ(0, index2);                                                    \
+      DCHECK_EQ(0u, index2);                                                   \
       __ cmpl(index1, length);                                                 \
       ool = new (zone()) OutOfLineLoadZero(this, result);                      \
     } else {                                                                   \
@@ -559,7 +559,7 @@ class WasmOutOfLineTrap final : public OutOfLineCode {
     auto value = i.InputDoubleRegister(4);                                   \
     if (instr->InputAt(3)->IsRegister()) {                                   \
       auto length = i.InputRegister(3);                                      \
-      DCHECK_EQ(0, index2);                                                  \
+      DCHECK_EQ(0u, index2);                                                 \
       Label done;                                                            \
       __ cmpl(index1, length);                                               \
       __ j(above_equal, &done, Label::kNear);                                \
@@ -614,7 +614,7 @@ class WasmOutOfLineTrap final : public OutOfLineCode {
     auto index2 = i.InputUint32(2);                                            \
     if (instr->InputAt(3)->IsRegister()) {                                     \
       auto length = i.InputRegister(3);                                        \
-      DCHECK_EQ(0, index2);                                                    \
+      DCHECK_EQ(0u, index2);                                                   \
       Label done;                                                              \
       __ cmpl(index1, length);                                                 \
       __ j(above_equal, &done, Label::kNear);                                  \
@@ -2508,7 +2508,7 @@ void CodeGenerator::AssembleReturn(InstructionOperand* pop) {
   if (pop->IsImmediate()) {
     DCHECK_EQ(Constant::kInt32, g.ToConstant(pop).type());
     pop_size += g.ToConstant(pop).ToInt32() * kPointerSize;
-    CHECK_LT(pop_size, std::numeric_limits<int>::max());
+    CHECK_LT(pop_size, static_cast<size_t>(std::numeric_limits<int>::max()));
     __ Ret(static_cast<int>(pop_size), rcx);
   } else {
     Register pop_reg = g.ToRegister(pop);

src/compiler/x64/unwinding-info-writer-x64.cc

@@ -15,7 +15,8 @@ void UnwindingInfoWriter::BeginInstructionBlock(int pc_offset,
 
   block_will_exit_ = false;
 
-  DCHECK_LT(block->rpo_number().ToInt(), block_initial_states_.size());
+  DCHECK_LT(block->rpo_number().ToInt(),
+            static_cast<int>(block_initial_states_.size()));
   const BlockInitialState* initial_state =
       block_initial_states_[block->rpo_number().ToInt()];
   if (initial_state) {
@@ -47,7 +48,7 @@ void UnwindingInfoWriter::EndInstructionBlock(const InstructionBlock* block) {
 
   for (const RpoNumber& successor : block->successors()) {
     int successor_index = successor.ToInt();
-    DCHECK_LT(successor_index, block_initial_states_.size());
+    DCHECK_LT(successor_index, static_cast<int>(block_initial_states_.size()));
     const BlockInitialState* existing_state =
         block_initial_states_[successor_index];
     // If we already had an entry for this BB, check that the values are the

src/compiler/x87/code-generator-x87.cc

@@ -2456,7 +2456,7 @@ void CodeGenerator::AssembleReturn(InstructionOperand* pop) {
     __ VerifyX87StackDepth(1);
   }
   bool clear_stack = true;
-  for (int i = 0; i < descriptor->ReturnCount(); i++) {
+  for (size_t i = 0; i < descriptor->ReturnCount(); i++) {
     MachineRepresentation rep = descriptor->GetReturnType(i).representation();
     LinkageLocation loc = descriptor->GetReturnLocation(i);
     if (IsFloatingPoint(rep) && loc == LinkageLocation::ForRegister(0)) {

src/eh-frame.cc

@@ -252,7 +252,7 @@ void EhFrameWriter::AdvanceLocation(int pc_offset) {
   DCHECK_GE(pc_offset, last_pc_offset_);
   uint32_t delta = pc_offset - last_pc_offset_;
 
-  DCHECK_EQ(delta % EhFrameConstants::kCodeAlignmentFactor, 0);
+  DCHECK_EQ(delta % EhFrameConstants::kCodeAlignmentFactor, 0u);
   uint32_t factored_delta = delta / EhFrameConstants::kCodeAlignmentFactor;
 
   if (factored_delta <= EhFrameConstants::kLocationMask) {

test/cctest/compiler/test-run-load-store.cc

@@ -278,7 +278,7 @@ void RunUnalignedLoadStoreUnalignedAccess(MachineType rep) {
   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);
@@ -523,7 +523,7 @@ void RunLoadStoreSignExtend64(TestAlignment t) {
 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());
@@ -1090,7 +1090,7 @@ void TestRunOobCheckedLoadT_pseudo(uint64_t x, bool length_is_immediate) {
   }
 
   // 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);

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

@@ -6359,7 +6359,7 @@ TEST(RunTryTruncateFloat64ToUint64WithCheck) {
   FOR_FLOAT64_INPUTS(i) {
     if (*i < 18446744073709551616.0 && *i > -1) {
       // Conversions within this range should succeed.
-      CHECK_EQ(static_cast<uint64_t>(*i), m.Call(*i));
+      CHECK_EQ(static_cast<uint64_t>(*i), static_cast<uint64_t>(m.Call(*i)));
       CHECK_NE(0, success);
     } else {
       m.Call(*i);

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

@@ -51,7 +51,7 @@ static void RunLoadStoreRelocation(MachineType rep) {
     raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
     new_raw[i] = static_cast<byte>((i + sizeof(CType)) ^ 0xAA);
   }
-  int32_t OK = 0x29000;
+  uint32_t OK = 0x29000;
   RawMachineAssemblerTester<uint32_t> m;
   Node* base = m.RelocatableIntPtrConstant(reinterpret_cast<intptr_t>(raw),
                                            RelocInfo::WASM_MEMORY_REFERENCE);
@@ -166,5 +166,5 @@ TEST(Uint32LessThanRelocation) {
   UpdateMemoryReferences(code, reinterpret_cast<Address>(1234),
                          reinterpret_cast<Address>(1234), 0x200, 0x400);
   // Check that after limit is increased, index is within bounds.
-  CHECK_EQ(0xaced, m.Call());
+  CHECK_EQ(0xacedu, m.Call());
 }

test/cctest/test-assembler-arm.cc

@@ -1818,13 +1818,11 @@ TEST(uxtah) {
   }
 }
 
-
 #define TEST_RBIT(expected_, input_)                       \
   t.input = input_;                                        \
   t.result = 0;                                            \
   dummy = CALL_GENERATED_CODE(isolate, f, &t, 0, 0, 0, 0); \
-  CHECK_EQ(expected_, t.result);
-
+  CHECK_EQ(static_cast<uint32_t>(expected_), t.result);
 
 TEST(rbit) {
   CcTest::InitializeVM();
@@ -2808,21 +2806,21 @@ TEST(unaligned_loads) {
 #endif
   uint64_t data = UINT64_C(0x84838281807f7e7d);
   dummy = CALL_GENERATED_CODE(isolate, f, &t, &data, 0, 0, 0);
-  CHECK_EQ(0x00007e7d, t.ldrh);
-  CHECK_EQ(0x00007e7d, t.ldrsh);
-  CHECK_EQ(0x807f7e7d, t.ldr);
+  CHECK_EQ(0x00007e7du, t.ldrh);
+  CHECK_EQ(0x00007e7du, t.ldrsh);
+  CHECK_EQ(0x807f7e7du, t.ldr);
   dummy = CALL_GENERATED_CODE(isolate, f, &t, &data, 1, 0, 0);
-  CHECK_EQ(0x00007f7e, t.ldrh);
-  CHECK_EQ(0x00007f7e, t.ldrsh);
-  CHECK_EQ(0x81807f7e, t.ldr);
+  CHECK_EQ(0x00007f7eu, t.ldrh);
+  CHECK_EQ(0x00007f7eu, t.ldrsh);
+  CHECK_EQ(0x81807f7eu, t.ldr);
   dummy = CALL_GENERATED_CODE(isolate, f, &t, &data, 2, 0, 0);
-  CHECK_EQ(0x0000807f, t.ldrh);
-  CHECK_EQ(0xffff807f, t.ldrsh);
-  CHECK_EQ(0x8281807f, t.ldr);
+  CHECK_EQ(0x0000807fu, t.ldrh);
+  CHECK_EQ(0xffff807fu, t.ldrsh);
+  CHECK_EQ(0x8281807fu, t.ldr);
   dummy = CALL_GENERATED_CODE(isolate, f, &t, &data, 3, 0, 0);
-  CHECK_EQ(0x00008180, t.ldrh);
-  CHECK_EQ(0xffff8180, t.ldrsh);
-  CHECK_EQ(0x83828180, t.ldr);
+  CHECK_EQ(0x00008180u, t.ldrh);
+  CHECK_EQ(0xffff8180u, t.ldrsh);
+  CHECK_EQ(0x83828180u, t.ldr);
 }
 
 TEST(unaligned_stores) {

test/unittests/compiler/mips64/instruction-selector-mips64-unittest.cc

@@ -332,7 +332,7 @@ TEST_P(InstructionSelectorCmpTest, Parameter) {
 
   if (FLAG_debug_code &&
       type.representation() == MachineRepresentation::kWord32) {
-    ASSERT_EQ(6, s.size());
+    ASSERT_EQ(6U, s.size());
 
     EXPECT_EQ(cmp.mi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(2U, s[0]->InputCount());

test/unittests/eh-frame-iterator-unittest.cc

@@ -40,7 +40,7 @@ TEST_F(EhFrameIteratorTest, Skip) {
 TEST_F(EhFrameIteratorTest, ULEB128Decoding) {
   static const byte kEncoded[] = {0xe5, 0x8e, 0x26};
   EhFrameIterator iterator(&kEncoded[0], &kEncoded[0] + sizeof(kEncoded));
-  EXPECT_EQ(624485, iterator.GetNextULeb128());
+  EXPECT_EQ(624485u, iterator.GetNextULeb128());
   EXPECT_TRUE(iterator.Done());
 }
 

test/unittests/eh-frame-writer-unittest.cc

@@ -75,7 +75,7 @@ TEST_F(EhFrameWriterTest, FDEHeader) {
 }
 
 TEST_F(EhFrameWriterTest, SetOffset) {
-  static const int kOffset = 0x0badc0de;
+  static const uint32_t kOffset = 0x0badc0de;
 
   EhFrameWriter writer(zone());
   writer.Initialize();
@@ -91,8 +91,8 @@ TEST_F(EhFrameWriterTest, SetOffset) {
 }
 
 TEST_F(EhFrameWriterTest, IncreaseOffset) {
-  static const int kFirstOffset = 121;
-  static const int kSecondOffset = 16;
+  static const uint32_t kFirstOffset = 121;
+  static const uint32_t kSecondOffset = 16;
 
   EhFrameWriter writer(zone());
   writer.Initialize();
@@ -125,12 +125,13 @@ TEST_F(EhFrameWriterTest, SetRegister) {
 
   EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfaRegister,
             iterator.GetNextOpcode());
-  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULeb128());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
 }
 
 TEST_F(EhFrameWriterTest, SetRegisterAndOffset) {
   Register test_register = Register::from_code(kTestRegisterCode);
-  static const int kOffset = 0x0badc0de;
+  static const uint32_t kOffset = 0x0badc0de;
 
   EhFrameWriter writer(zone());
   writer.Initialize();
@@ -141,7 +142,8 @@ TEST_F(EhFrameWriterTest, SetRegisterAndOffset) {
   iterator.SkipToFdeDirectives();
 
   EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kDefCfa, iterator.GetNextOpcode());
-  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULeb128());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
   EXPECT_EQ(kOffset, iterator.GetNextULeb128());
 }
 
@@ -261,7 +263,7 @@ TEST_F(EhFrameWriterTest, PcOffsetEncoding16bitDelta) {
 }
 
 TEST_F(EhFrameWriterTest, PcOffsetEncoding32bit) {
-  static const int kOffset = kMaxUInt16 + 42;
+  static const uint32_t kOffset = kMaxUInt16 + 42;
 
   EhFrameWriter writer(zone());
   writer.Initialize();
@@ -277,8 +279,8 @@ TEST_F(EhFrameWriterTest, PcOffsetEncoding32bit) {
 }
 
 TEST_F(EhFrameWriterTest, PcOffsetEncoding32bitDelta) {
-  static const int kFirstOffset = kMaxUInt16 + 0x42;
-  static const int kSecondOffset = kMaxUInt16 + 0x67;
+  static const uint32_t kFirstOffset = kMaxUInt16 + 0x42;
+  static const uint32_t kSecondOffset = kMaxUInt16 + 0x67;
 
   EhFrameWriter writer(zone());
   writer.Initialize();
@@ -311,8 +313,9 @@ TEST_F(EhFrameWriterTest, SaveRegisterUnsignedOffset) {
   iterator.SkipToFdeDirectives();
 
   EXPECT_EQ((2 << 6) | kTestRegisterCode, iterator.GetNextByte());
-  EXPECT_EQ(kOffset / EhFrameConstants::kDataAlignmentFactor,
-            iterator.GetNextULeb128());
+  EXPECT_EQ(
+      static_cast<uint32_t>(kOffset / EhFrameConstants::kDataAlignmentFactor),
+      iterator.GetNextULeb128());
 }
 
 TEST_F(EhFrameWriterTest, SaveRegisterSignedOffset) {
@@ -332,7 +335,8 @@ TEST_F(EhFrameWriterTest, SaveRegisterSignedOffset) {
 
   EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kOffsetExtendedSf,
             iterator.GetNextOpcode());
-  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULeb128());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
   EXPECT_EQ(kOffset / EhFrameConstants::kDataAlignmentFactor,
             iterator.GetNextSLeb128());
 }
@@ -350,7 +354,8 @@ TEST_F(EhFrameWriterTest, RegisterNotModified) {
 
   EXPECT_EQ(EhFrameConstants::DwarfOpcodes::kSameValue,
             iterator.GetNextOpcode());
-  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULeb128());
+  EXPECT_EQ(static_cast<uint32_t>(kTestRegisterCode),
+            iterator.GetNextULeb128());
 }
 
 TEST_F(EhFrameWriterTest, RegisterFollowsInitialRule) {