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 117 matching lines @@
 }
 
 
 bool InstructionSelector::CanCover(Node* user, Node* node) const {
   return node->OwnedBy(user) &&
          schedule()->block(node) == schedule()->block(user);
 }
 
 
 int InstructionSelector::GetVirtualRegister(const Node* node) {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   size_t const id = node->id();
   DCHECK_LT(id, virtual_registers_.size());
   int virtual_register = virtual_registers_[id];
   if (virtual_register == UnallocatedOperand::kInvalidVirtualRegister) {
     virtual_register = sequence()->NextVirtualRegister();
     virtual_registers_[id] = virtual_register;
   }
   return virtual_register;
 }
 
 
 const std::map<NodeId, int> InstructionSelector::GetVirtualRegistersForTesting()
     const {
   std::map<NodeId, int> virtual_registers;
   for (size_t n = 0; n < virtual_registers_.size(); ++n) {
     if (virtual_registers_[n] != UnallocatedOperand::kInvalidVirtualRegister) {
       NodeId const id = static_cast<NodeId>(n);
       virtual_registers.insert(std::make_pair(id, virtual_registers_[n]));
     }
   }
   return virtual_registers;
 }
 
 
 bool InstructionSelector::IsDefined(Node* node) const {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   size_t const id = node->id();
   DCHECK_LT(id, defined_.size());
   return defined_[id];
 }
 
 
 void InstructionSelector::MarkAsDefined(Node* node) {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   size_t const id = node->id();
   DCHECK_LT(id, defined_.size());
   defined_[id] = true;
 }
 
 
 bool InstructionSelector::IsUsed(Node* node) const {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   if (!node->op()->HasProperty(Operator::kEliminatable)) return true;
   size_t const id = node->id();
   DCHECK_LT(id, used_.size());
   return used_[id];
 }
 
 
 void InstructionSelector::MarkAsUsed(Node* node) {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   size_t const id = node->id();
   DCHECK_LT(id, used_.size());
   used_[id] = true;
 }
 
 
 bool InstructionSelector::IsDouble(const Node* node) const {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   int const virtual_register = virtual_registers_[node->id()];
   if (virtual_register == UnallocatedOperand::kInvalidVirtualRegister) {
     return false;
   }
   return sequence()->IsDouble(virtual_register);
 }
 
 
 void InstructionSelector::MarkAsDouble(Node* node) {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   DCHECK(!IsReference(node));
   sequence()->MarkAsDouble(GetVirtualRegister(node));
 }
 
 
 bool InstructionSelector::IsReference(const Node* node) const {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   int const virtual_register = virtual_registers_[node->id()];
   if (virtual_register == UnallocatedOperand::kInvalidVirtualRegister) {
     return false;
   }
   return sequence()->IsReference(virtual_register);
 }
 
 
 void InstructionSelector::MarkAsReference(Node* node) {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   DCHECK(!IsDouble(node));
   sequence()->MarkAsReference(GetVirtualRegister(node));
 }
 
 
 void InstructionSelector::MarkAsRepresentation(MachineType rep,
                                                InstructionOperand* op) {
   UnallocatedOperand* unalloc = UnallocatedOperand::cast(op);
   switch (RepresentationOf(rep)) {
     case kRepFloat32:
     case kRepFloat64:
       sequence()->MarkAsDouble(unalloc->virtual_register());
       break;
     case kRepTagged:
       sequence()->MarkAsReference(unalloc->virtual_register());
       break;
     default:
       break;
   }
 }
 
 
 void InstructionSelector::MarkAsRepresentation(MachineType rep, Node* node) {
-  DCHECK_NOT_NULL(node);
+  DCHECK(node);
   switch (RepresentationOf(rep)) {
     case kRepFloat32:
     case kRepFloat64:
       MarkAsDouble(node);
       break;
     case kRepTagged:
       MarkAsReference(node);
       break;
     default:
       break;
@@ skipping 33 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 64 matching lines @@
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 MachineType InstructionSelector::GetMachineType(Node* node) {
-  DCHECK_NOT_NULL(schedule()->block(node));  // should only use scheduled nodes.
+  DCHECK(schedule()->block(node));  // should only use scheduled nodes.
   switch (node->opcode()) {
     case IrOpcode::kStart:
     case IrOpcode::kLoop:
     case IrOpcode::kEnd:
     case IrOpcode::kBranch:
     case IrOpcode::kIfTrue:
     case IrOpcode::kIfFalse:
     case IrOpcode::kEffectPhi:
     case IrOpcode::kEffectSet:
     case IrOpcode::kMerge:
@@ skipping 110 matching lines @@
       return kMachBool;
     default:
       V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
                node->opcode(), node->op()->mnemonic(), node->id());
   }
   return kMachNone;
 }
 
 
 void InstructionSelector::VisitNode(Node* node) {
-  DCHECK_NOT_NULL(schedule()->block(node));  // should only use scheduled nodes.
+  DCHECK(schedule()->block(node));  // should only use scheduled nodes.
   SourcePosition source_position = source_positions_->GetSourcePosition(node);
   if (!source_position.IsUnknown()) {
     DCHECK(!source_position.IsInvalid());
     if (FLAG_turbo_source_positions || node->opcode() == IrOpcode::kCall) {
       Emit(SourcePositionInstruction::New(instruction_zone(), source_position));
     }
   }
   switch (node->opcode()) {
     case IrOpcode::kStart:
     case IrOpcode::kLoop:
@@ skipping 493 matching lines @@
 MachineOperatorBuilder::Flags
 InstructionSelector::SupportedMachineOperatorFlags() {
   return MachineOperatorBuilder::Flag::kNoFlags;
 }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8