Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.".

src/compiler/instruction-selector.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 "src/compiler/instruction-selector.h"
 
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/pipeline.h"
@@ skipping 22 matching lines @@
                          UnallocatedOperand::kInvalidVirtualRegister, zone) {
   instructions_.reserve(node_count);
 }
 
 
 void InstructionSelector::SelectInstructions() {
   // Mark the inputs of all phis in loop headers as used.
   BasicBlockVector* blocks = schedule()->rpo_order();
   for (auto const block : *blocks) {
     if (!block->IsLoopHeader()) continue;
-    DCHECK_LE(2, block->PredecessorCount());
+    DCHECK_LE(2u, block->PredecessorCount());
     for (Node* const phi : *block) {
       if (phi->opcode() != IrOpcode::kPhi) continue;
 
       // Mark all inputs as used.
       for (Node* const input : phi->inputs()) {
         MarkAsUsed(input);
       }
     }
   }
 
@@ skipping 281 matching lines @@
   if (buffer->descriptor->ReturnCount() > 0) {
     // Collect the projections that represent multiple outputs from this call.
     if (buffer->descriptor->ReturnCount() == 1) {
       buffer->output_nodes.push_back(call);
     } else {
       buffer->output_nodes.resize(buffer->descriptor->ReturnCount(), nullptr);
       for (auto use : call->uses()) {
         if (use->opcode() != IrOpcode::kProjection) continue;
         size_t const index = ProjectionIndexOf(use->op());
         DCHECK_LT(index, buffer->output_nodes.size());
-        DCHECK_EQ(nullptr, buffer->output_nodes[index]);
+        DCHECK(!buffer->output_nodes[index]);
         buffer->output_nodes[index] = use;
       }
     }
 
     // Filter out the outputs that aren't live because no projection uses them.
     size_t outputs_needed_by_framestate =
         buffer->frame_state_descriptor == NULL
             ? 0
             : buffer->frame_state_descriptor->state_combine()
                   .ConsumedOutputCount();
@@ skipping 72 matching lines @@
     DCHECK((*iter)->op()->opcode() != IrOpcode::kFrameState);
     if (index == 0) continue;  // The first argument (callee) is already done.
     InstructionOperand* op =
         g.UseLocation(*iter, buffer->descriptor->GetInputLocation(index),
                       buffer->descriptor->GetInputType(index));
     if (UnallocatedOperand::cast(op)->HasFixedSlotPolicy()) {
       int stack_index = -UnallocatedOperand::cast(op)->fixed_slot_index() - 1;
       if (static_cast<size_t>(stack_index) >= buffer->pushed_nodes.size()) {
         buffer->pushed_nodes.resize(stack_index + 1, NULL);
       }
-      DCHECK_EQ(NULL, buffer->pushed_nodes[stack_index]);
+      DCHECK(!buffer->pushed_nodes[stack_index]);
       buffer->pushed_nodes[stack_index] = *iter;
       pushed_count++;
     } else {
       buffer->instruction_args.push_back(op);
     }
   }
   CHECK_EQ(pushed_count, static_cast<int>(buffer->pushed_nodes.size()));
   DCHECK(static_cast<size_t>(input_count) ==
          (buffer->instruction_args.size() + buffer->pushed_nodes.size() -
           buffer->frame_state_value_count()));
 }
 
 
 void InstructionSelector::VisitBlock(BasicBlock* block) {
-  DCHECK_EQ(NULL, current_block_);
+  DCHECK(!current_block_);
   current_block_ = block;
   int current_block_end = static_cast<int>(instructions_.size());
 
   // Generate code for the block control "top down", but schedule the code
   // "bottom up".
   VisitControl(block);
   std::reverse(instructions_.begin() + current_block_end, instructions_.end());
 
   // Visit code in reverse control flow order, because architecture-specific
   // matching may cover more than one node at a time.
@@ skipping 709 matching lines @@
 MachineOperatorBuilder::Flags
 InstructionSelector::SupportedMachineOperatorFlags() {
   return MachineOperatorBuilder::Flag::kNoFlags;
 }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8