Rename ASSERT* to DCHECK*.

src/compiler/instruction.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.h"
 
 #include "src/compiler/common-operator.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 107 matching lines @@
     first = false;
     os << *move;
   }
   return os;
 }
 
 
 void PointerMap::RecordPointer(InstructionOperand* op, Zone* zone) {
   // Do not record arguments as pointers.
   if (op->IsStackSlot() && op->index() < 0) return;
-  ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
+  DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   pointer_operands_.Add(op, zone);
 }
 
 
 void PointerMap::RemovePointer(InstructionOperand* op) {
   // Do not record arguments as pointers.
   if (op->IsStackSlot() && op->index() < 0) return;
-  ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
+  DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   for (int i = 0; i < pointer_operands_.length(); ++i) {
     if (pointer_operands_[i]->Equals(op)) {
       pointer_operands_.Remove(i);
       --i;
     }
   }
 }
 
 
 void PointerMap::RecordUntagged(InstructionOperand* op, Zone* zone) {
   // Do not record arguments as pointers.
   if (op->IsStackSlot() && op->index() < 0) return;
-  ASSERT(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
+  DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
   untagged_operands_.Add(op, zone);
 }
 
 
 OStream& operator<<(OStream& os, const PointerMap& pm) {
   os << "{";
   for (ZoneList<InstructionOperand*>::iterator op =
            pm.pointer_operands_.begin();
        op != pm.pointer_operands_.end(); ++op) {
     if (op != pm.pointer_operands_.begin()) os << ";";
@@ skipping 164 matching lines @@
 void InstructionSequence::StartBlock(BasicBlock* block) {
   block->code_start_ = static_cast<int>(instructions_.size());
   BlockStartInstruction* block_start =
       BlockStartInstruction::New(zone(), block);
   AddInstruction(block_start, block);
 }
 
 
 void InstructionSequence::EndBlock(BasicBlock* block) {
   int end = static_cast<int>(instructions_.size());
-  ASSERT(block->code_start_ >= 0 && block->code_start_ < end);
+  DCHECK(block->code_start_ >= 0 && block->code_start_ < end);
   block->code_end_ = end;
 }
 
 
 int InstructionSequence::AddInstruction(Instruction* instr, BasicBlock* block) {
   // TODO(titzer): the order of these gaps is a holdover from Lithium.
   GapInstruction* gap = GapInstruction::New(zone());
   if (instr->IsControl()) instructions_.push_back(gap);
   int index = static_cast<int>(instructions_.size());
   instructions_.push_back(instr);
   if (!instr->IsControl()) instructions_.push_back(gap);
   if (instr->NeedsPointerMap()) {
-    ASSERT(instr->pointer_map() == NULL);
+    DCHECK(instr->pointer_map() == NULL);
     PointerMap* pointer_map = new (zone()) PointerMap(zone());
     pointer_map->set_instruction_position(index);
     instr->set_pointer_map(pointer_map);
     pointer_maps_.push_back(pointer_map);
   }
   return index;
 }
 
 
 BasicBlock* InstructionSequence::GetBasicBlock(int instruction_index) {
   // TODO(turbofan): Optimize this.
   for (;;) {
-    ASSERT_LE(0, instruction_index);
+    DCHECK_LE(0, instruction_index);
     Instruction* instruction = InstructionAt(instruction_index--);
     if (instruction->IsBlockStart()) {
       return BlockStartInstruction::cast(instruction)->block();
     }
   }
 }
 
 
 bool InstructionSequence::IsReference(int virtual_register) const {
   return references_.find(virtual_register) != references_.end();
@@ skipping 103 matching lines @@
       os << " B" << (*iter)->id();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8