Rename ASSERT* to DCHECK*.

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-inl.h"
 #include "src/compiler/pipeline.h"
@@ skipping 12 matching lines @@
       defined_(graph()->NodeCount(), false, BoolVector::allocator_type(zone())),
       used_(graph()->NodeCount(), false, BoolVector::allocator_type(zone())) {}
 
 
 void InstructionSelector::SelectInstructions() {
   // Mark the inputs of all phis in loop headers as used.
   BasicBlockVector* blocks = schedule()->rpo_order();
   for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
     BasicBlock* block = *i;
     if (!block->IsLoopHeader()) continue;
-    ASSERT_NE(0, block->PredecessorCount());
-    ASSERT_NE(1, block->PredecessorCount());
+    DCHECK_NE(0, block->PredecessorCount());
+    DCHECK_NE(1, block->PredecessorCount());
     for (BasicBlock::const_iterator j = block->begin(); j != block->end();
          ++j) {
       Node* phi = *j;
       if (phi->opcode() != IrOpcode::kPhi) continue;
 
       // Mark all inputs as used.
       Node::Inputs inputs = phi->inputs();
       for (InputIter k = inputs.begin(); k != inputs.end(); ++k) {
         MarkAsUsed(*k);
       }
@@ skipping 99 matching lines @@
 }
 
 
 bool InstructionSelector::CanCover(Node* user, Node* node) const {
   return node->OwnedBy(user) &&
          schedule()->block(node) == schedule()->block(user);
 }
 
 
 bool InstructionSelector::IsDefined(Node* node) const {
-  ASSERT_NOT_NULL(node);
+  DCHECK_NOT_NULL(node);
   NodeId id = node->id();
-  ASSERT(id >= 0);
-  ASSERT(id < static_cast<NodeId>(defined_.size()));
+  DCHECK(id >= 0);
+  DCHECK(id < static_cast<NodeId>(defined_.size()));
   return defined_[id];
 }
 
 
 void InstructionSelector::MarkAsDefined(Node* node) {
-  ASSERT_NOT_NULL(node);
+  DCHECK_NOT_NULL(node);
   NodeId id = node->id();
-  ASSERT(id >= 0);
-  ASSERT(id < static_cast<NodeId>(defined_.size()));
+  DCHECK(id >= 0);
+  DCHECK(id < static_cast<NodeId>(defined_.size()));
   defined_[id] = true;
 }
 
 
 bool InstructionSelector::IsUsed(Node* node) const {
   if (!node->op()->HasProperty(Operator::kEliminatable)) return true;
   NodeId id = node->id();
-  ASSERT(id >= 0);
-  ASSERT(id < static_cast<NodeId>(used_.size()));
+  DCHECK(id >= 0);
+  DCHECK(id < static_cast<NodeId>(used_.size()));
   return used_[id];
 }
 
 
 void InstructionSelector::MarkAsUsed(Node* node) {
-  ASSERT_NOT_NULL(node);
+  DCHECK_NOT_NULL(node);
   NodeId id = node->id();
-  ASSERT(id >= 0);
-  ASSERT(id < static_cast<NodeId>(used_.size()));
+  DCHECK(id >= 0);
+  DCHECK(id < static_cast<NodeId>(used_.size()));
   used_[id] = true;
 }
 
 
 bool InstructionSelector::IsDouble(const Node* node) const {
-  ASSERT_NOT_NULL(node);
+  DCHECK_NOT_NULL(node);
   return sequence()->IsDouble(node->id());
 }
 
 
 void InstructionSelector::MarkAsDouble(Node* node) {
-  ASSERT_NOT_NULL(node);
-  ASSERT(!IsReference(node));
+  DCHECK_NOT_NULL(node);
+  DCHECK(!IsReference(node));
   sequence()->MarkAsDouble(node->id());
 
   // Propagate "doubleness" throughout phis.
   for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
     Node* user = *i;
     if (user->opcode() != IrOpcode::kPhi) continue;
     if (IsDouble(user)) continue;
     MarkAsDouble(user);
   }
 }
 
 
 bool InstructionSelector::IsReference(const Node* node) const {
-  ASSERT_NOT_NULL(node);
+  DCHECK_NOT_NULL(node);
   return sequence()->IsReference(node->id());
 }
 
 
 void InstructionSelector::MarkAsReference(Node* node) {
-  ASSERT_NOT_NULL(node);
-  ASSERT(!IsDouble(node));
+  DCHECK_NOT_NULL(node);
+  DCHECK(!IsDouble(node));
   sequence()->MarkAsReference(node->id());
 
   // Propagate "referenceness" throughout phis.
   for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
     Node* user = *i;
     if (user->opcode() != IrOpcode::kPhi) continue;
     if (IsReference(user)) continue;
     MarkAsReference(user);
   }
 }
 
 
 void InstructionSelector::MarkAsRepresentation(MachineRepresentation rep,
                                                Node* node) {
-  ASSERT_NOT_NULL(node);
+  DCHECK_NOT_NULL(node);
   if (rep == kMachineFloat64) MarkAsDouble(node);
   if (rep == kMachineTagged) MarkAsReference(node);
 }
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 CallBuffer::CallBuffer(Zone* zone, CallDescriptor* d)
     : output_count(0),
       descriptor(d),
@@ skipping 12 matching lines @@
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 void InstructionSelector::InitializeCallBuffer(Node* call, CallBuffer* buffer,
                                                bool call_code_immediate,
                                                bool call_address_immediate,
                                                BasicBlock* cont_node,
                                                BasicBlock* deopt_node) {
   OperandGenerator g(this);
-  ASSERT_EQ(call->op()->OutputCount(), buffer->descriptor->ReturnCount());
-  ASSERT_EQ(NodeProperties::GetValueInputCount(call), buffer->input_count());
+  DCHECK_EQ(call->op()->OutputCount(), buffer->descriptor->ReturnCount());
+  DCHECK_EQ(NodeProperties::GetValueInputCount(call), buffer->input_count());
 
   if (buffer->descriptor->ReturnCount() > 0) {
     // Collect the projections that represent multiple outputs from this call.
     if (buffer->descriptor->ReturnCount() == 1) {
       buffer->output_nodes[0] = call;
     } else {
       call->CollectProjections(buffer->descriptor->ReturnCount(),
                                buffer->output_nodes);
     }
 
@@ skipping 33 matching lines @@
   }
 
   int input_count = buffer->input_count();
 
   // Split the arguments into pushed_nodes and fixed_args. Pushed arguments
   // require an explicit push instruction before the call and do not appear
   // as arguments to the call. Everything else ends up as an InstructionOperand
   // argument to the call.
   InputIter iter(call->inputs().begin());
   for (int index = 0; index < input_count; ++iter, ++index) {
-    ASSERT(iter != call->inputs().end());
-    ASSERT(index == iter.index());
+    DCHECK(iter != call->inputs().end());
+    DCHECK(index == iter.index());
     if (index == 0) continue;  // The first argument (callee) is already done.
     InstructionOperand* op =
         g.UseLocation(*iter, buffer->descriptor->GetInputLocation(index));
     if (UnallocatedOperand::cast(op)->HasFixedSlotPolicy()) {
       int stack_index = -UnallocatedOperand::cast(op)->fixed_slot_index() - 1;
-      ASSERT(buffer->pushed_nodes[stack_index] == NULL);
+      DCHECK(buffer->pushed_nodes[stack_index] == NULL);
       buffer->pushed_nodes[stack_index] = *iter;
       buffer->pushed_count++;
     } else {
       buffer->fixed_and_control_args[buffer->fixed_count] = op;
       buffer->fixed_count++;
     }
   }
 
   // If the call can deoptimize, we add the continuation and deoptimization
   // block labels.
   if (buffer->descriptor->CanLazilyDeoptimize()) {
-    ASSERT(cont_node != NULL);
-    ASSERT(deopt_node != NULL);
+    DCHECK(cont_node != NULL);
+    DCHECK(deopt_node != NULL);
     buffer->fixed_and_control_args[buffer->fixed_count] = g.Label(cont_node);
     buffer->fixed_and_control_args[buffer->fixed_count + 1] =
         g.Label(deopt_node);
   } else {
-    ASSERT(cont_node == NULL);
-    ASSERT(deopt_node == NULL);
+    DCHECK(cont_node == NULL);
+    DCHECK(deopt_node == NULL);
   }
 
-  ASSERT(input_count == (buffer->fixed_count + buffer->pushed_count));
+  DCHECK(input_count == (buffer->fixed_count + buffer->pushed_count));
 }
 
 
 void InstructionSelector::VisitBlock(BasicBlock* block) {
-  ASSERT_EQ(NULL, current_block_);
+  DCHECK_EQ(NULL, 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 28 matching lines @@
 #endif
 }
 
 
 void InstructionSelector::VisitControl(BasicBlock* block) {
   Node* input = block->control_input_;
   switch (block->control_) {
     case BasicBlockData::kGoto:
       return VisitGoto(block->SuccessorAt(0));
     case BasicBlockData::kBranch: {
-      ASSERT_EQ(IrOpcode::kBranch, input->opcode());
+      DCHECK_EQ(IrOpcode::kBranch, input->opcode());
       BasicBlock* tbranch = block->SuccessorAt(0);
       BasicBlock* fbranch = block->SuccessorAt(1);
       // SSA deconstruction requires targets of branches not to have phis.
       // Edge split form guarantees this property, but is more strict.
       CheckNoPhis(tbranch);
       CheckNoPhis(fbranch);
       if (tbranch == fbranch) return VisitGoto(tbranch);
       return VisitBranch(input, tbranch, fbranch);
     }
     case BasicBlockData::kReturn: {
       // If the result itself is a return, return its input.
       Node* value = (input != NULL && input->opcode() == IrOpcode::kReturn)
                         ? input->InputAt(0)
                         : input;
       return VisitReturn(value);
     }
     case BasicBlockData::kThrow:
       return VisitThrow(input);
     case BasicBlockData::kDeoptimize:
       return VisitDeoptimization(input);
     case BasicBlockData::kCall: {
       BasicBlock* deoptimization = block->SuccessorAt(0);
       BasicBlock* continuation = block->SuccessorAt(1);
       VisitCall(input, continuation, deoptimization);
       break;
     }
     case BasicBlockData::kNone: {
       // TODO(titzer): exit block doesn't have control.
-      ASSERT(input == NULL);
+      DCHECK(input == NULL);
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void InstructionSelector::VisitNode(Node* node) {
-  ASSERT_NOT_NULL(schedule()->block(node));  // should only use scheduled nodes.
+  DCHECK_NOT_NULL(schedule()->block(node));  // should only use scheduled nodes.
   SourcePosition source_position = source_positions_->GetSourcePosition(node);
   if (!source_position.IsUnknown()) {
-    ASSERT(!source_position.IsInvalid());
+    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:
     case IrOpcode::kEnd:
     case IrOpcode::kBranch:
     case IrOpcode::kIfTrue:
@@ skipping 331 matching lines @@
 
 void InstructionSelector::VisitProjection(Node* node) {
   OperandGenerator g(this);
   Node* value = node->InputAt(0);
   switch (value->opcode()) {
     case IrOpcode::kInt32AddWithOverflow:
     case IrOpcode::kInt32SubWithOverflow:
       if (OpParameter<int32_t>(node) == 0) {
         Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
       } else {
-        ASSERT_EQ(1, OpParameter<int32_t>(node));
+        DCHECK_EQ(1, OpParameter<int32_t>(node));
         MarkAsUsed(value);
       }
       break;
     default:
       break;
   }
 }
 
 
 void InstructionSelector::VisitConstant(Node* node) {
@@ skipping 135 matching lines @@
   }
 }
 
 
 void InstructionSelector::VisitThrow(Node* value) {
   UNIMPLEMENTED();  // TODO(titzer)
 }
 
 
 void InstructionSelector::VisitDeoptimization(Node* deopt) {
-  ASSERT(deopt->op()->opcode() == IrOpcode::kDeoptimize);
+  DCHECK(deopt->op()->opcode() == IrOpcode::kDeoptimize);
   Node* state = deopt->InputAt(0);
-  ASSERT(state->op()->opcode() == IrOpcode::kFrameState);
+  DCHECK(state->op()->opcode() == IrOpcode::kFrameState);
   FrameStateDescriptor descriptor = OpParameter<FrameStateDescriptor>(state);
   // TODO(jarin) We should also add an instruction input for every input to
   // the framestate node (and recurse for the inlined framestates).
   int deoptimization_id = sequence()->AddDeoptimizationEntry(descriptor);
   Emit(kArchDeoptimize | MiscField::encode(deoptimization_id), NULL);
 }
 
 
 #if !V8_TURBOFAN_TARGET
 
@@ skipping 33 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif  // !V8_TURBOFAN_TARGET
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8