Rename ASSERT* to DCHECK*.

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

 // Copyright 2013 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/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 19 matching lines @@
   Immediate InputImmediate(int index) {
     return ToImmediate(instr_->InputAt(index));
   }
 
   Operand OutputOperand() { return ToOperand(instr_->Output()); }
 
   Operand TempOperand(int index) { return ToOperand(instr_->TempAt(index)); }
 
   Operand ToOperand(InstructionOperand* op, int extra = 0) {
     if (op->IsRegister()) {
-      ASSERT(extra == 0);
+      DCHECK(extra == 0);
       return Operand(ToRegister(op));
     } else if (op->IsDoubleRegister()) {
-      ASSERT(extra == 0);
+      DCHECK(extra == 0);
       return Operand(ToDoubleRegister(op));
     }
-    ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());
+    DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
     // The linkage computes where all spill slots are located.
     FrameOffset offset = linkage()->GetFrameOffset(op->index(), frame(), extra);
     return Operand(offset.from_stack_pointer() ? esp : ebp, offset.offset());
   }
 
   Operand HighOperand(InstructionOperand* op) {
-    ASSERT(op->IsDoubleStackSlot());
+    DCHECK(op->IsDoubleStackSlot());
     return ToOperand(op, kPointerSize);
   }
 
   Immediate ToImmediate(InstructionOperand* operand) {
     Constant constant = ToConstant(operand);
     switch (constant.type()) {
       case Constant::kInt32:
         return Immediate(constant.ToInt32());
       case Constant::kFloat64:
         return Immediate(
@@ skipping 414 matching lines @@
 
 // Assembles boolean materializations after an instruction.
 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
                                         FlagsCondition condition) {
   IA32OperandConverter i(this, instr);
   Label done;
 
   // Materialize a full 32-bit 1 or 0 value. The result register is always the
   // last output of the instruction.
   Label check;
-  ASSERT_NE(0, instr->OutputCount());
+  DCHECK_NE(0, instr->OutputCount());
   Register reg = i.OutputRegister(instr->OutputCount() - 1);
   Condition cc = no_condition;
   switch (condition) {
     case kUnorderedEqual:
       __ j(parity_odd, &check, Label::kNear);
       __ mov(reg, Immediate(0));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kEqual:
       cc = equal;
@@ skipping 289 matching lines @@
   }
 }
 
 
 void CodeGenerator::AssembleMove(InstructionOperand* source,
                                  InstructionOperand* destination) {
   IA32OperandConverter g(this, NULL);
   // Dispatch on the source and destination operand kinds.  Not all
   // combinations are possible.
   if (source->IsRegister()) {
-    ASSERT(destination->IsRegister() || destination->IsStackSlot());
+    DCHECK(destination->IsRegister() || destination->IsStackSlot());
     Register src = g.ToRegister(source);
     Operand dst = g.ToOperand(destination);
     __ mov(dst, src);
   } else if (source->IsStackSlot()) {
-    ASSERT(destination->IsRegister() || destination->IsStackSlot());
+    DCHECK(destination->IsRegister() || destination->IsStackSlot());
     Operand src = g.ToOperand(source);
     if (destination->IsRegister()) {
       Register dst = g.ToRegister(destination);
       __ mov(dst, src);
     } else {
       Operand dst = g.ToOperand(destination);
       __ push(src);
       __ pop(dst);
     }
   } else if (source->IsConstant()) {
     Constant src_constant = g.ToConstant(source);
     if (src_constant.type() == Constant::kHeapObject) {
       Handle<HeapObject> src = src_constant.ToHeapObject();
       if (destination->IsRegister()) {
         Register dst = g.ToRegister(destination);
         __ LoadHeapObject(dst, src);
       } else {
-        ASSERT(destination->IsStackSlot());
+        DCHECK(destination->IsStackSlot());
         Operand dst = g.ToOperand(destination);
         AllowDeferredHandleDereference embedding_raw_address;
         if (isolate()->heap()->InNewSpace(*src)) {
           __ PushHeapObject(src);
           __ pop(dst);
         } else {
           __ mov(dst, src);
         }
       }
     } else if (destination->IsRegister()) {
       Register dst = g.ToRegister(destination);
       __ mov(dst, g.ToImmediate(source));
     } else if (destination->IsStackSlot()) {
       Operand dst = g.ToOperand(destination);
       __ mov(dst, g.ToImmediate(source));
     } else {
       double v = g.ToDouble(source);
       uint64_t int_val = BitCast<uint64_t, double>(v);
       int32_t lower = static_cast<int32_t>(int_val);
       int32_t upper = static_cast<int32_t>(int_val >> kBitsPerInt);
       if (destination->IsDoubleRegister()) {
         XMMRegister dst = g.ToDoubleRegister(destination);
         __ Move(dst, v);
       } else {
-        ASSERT(destination->IsDoubleStackSlot());
+        DCHECK(destination->IsDoubleStackSlot());
         Operand dst0 = g.ToOperand(destination);
         Operand dst1 = g.HighOperand(destination);
         __ mov(dst0, Immediate(lower));
         __ mov(dst1, Immediate(upper));
       }
     }
   } else if (source->IsDoubleRegister()) {
     XMMRegister src = g.ToDoubleRegister(source);
     if (destination->IsDoubleRegister()) {
       XMMRegister dst = g.ToDoubleRegister(destination);
       __ movaps(dst, src);
     } else {
-      ASSERT(destination->IsDoubleStackSlot());
+      DCHECK(destination->IsDoubleStackSlot());
       Operand dst = g.ToOperand(destination);
       __ movsd(dst, src);
     }
   } else if (source->IsDoubleStackSlot()) {
-    ASSERT(destination->IsDoubleRegister() || destination->IsDoubleStackSlot());
+    DCHECK(destination->IsDoubleRegister() || destination->IsDoubleStackSlot());
     Operand src = g.ToOperand(source);
     if (destination->IsDoubleRegister()) {
       XMMRegister dst = g.ToDoubleRegister(destination);
       __ movsd(dst, src);
     } else {
       // We rely on having xmm0 available as a fixed scratch register.
       Operand dst = g.ToOperand(destination);
       __ movsd(xmm0, src);
       __ movsd(dst, xmm0);
     }
@@ skipping 72 matching lines @@
     return false;
   }
   return *(code->instruction_start() + start_pc) ==
          v8::internal::Assembler::kNopByte;
 }
 
 #endif  // DEBUG
 }
 }
 }  // namespace v8::internal::compiler