Rename ASSERT* to DCHECK*.

src/compiler/x64/code-generator-x64.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 94 matching lines @@
       case Constant::kExternalReference:
       case Constant::kHeapObject:
         break;
     }
     UNREACHABLE();
     return Immediate(-1);
   }
 
   Operand ToOperand(InstructionOperand* op, int extra = 0) {
     RegisterOrOperand result = ToRegisterOrOperand(op, extra);
-    ASSERT_EQ(kOperand, result.type);
+    DCHECK_EQ(kOperand, result.type);
     return result.operand;
   }
 
   RegisterOrOperand ToRegisterOrOperand(InstructionOperand* op, int extra = 0) {
     RegisterOrOperand result;
     if (op->IsRegister()) {
-      ASSERT(extra == 0);
+      DCHECK(extra == 0);
       result.type = kRegister;
       result.reg = ToRegister(op);
       return result;
     } else if (op->IsDoubleRegister()) {
-      ASSERT(extra == 0);
-      ASSERT(extra == 0);
+      DCHECK(extra == 0);
+      DCHECK(extra == 0);
       result.type = kDoubleRegister;
       result.double_reg = ToDoubleRegister(op);
       return result;
     }
 
-    ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());
+    DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
 
     result.type = kOperand;
     // The linkage computes where all spill slots are located.
     FrameOffset offset = linkage()->GetFrameOffset(op->index(), frame(), extra);
     result.operand =
         Operand(offset.from_stack_pointer() ? rsp : rbp, offset.offset());
     return result;
   }
 
   Operand MemoryOperand(int* first_input) {
@@ skipping 253 matching lines @@
       bool lazy_deopt = (MiscField::decode(instr->opcode()) == 1);
       if (lazy_deopt) {
         RecordLazyDeoptimizationEntry(instr);
       }
       AddNopForSmiCodeInlining();
       break;
     }
     case kX64CallAddress:
       if (HasImmediateInput(instr, 0)) {
         Immediate64 imm = i.InputImmediate64(0);
-        ASSERT_EQ(kImm64Value, imm.type);
+        DCHECK_EQ(kImm64Value, imm.type);
         __ Call(reinterpret_cast<byte*>(imm.value), RelocInfo::NONE64);
       } else {
         __ call(i.InputRegister(0));
       }
       break;
     case kPopStack: {
       int words = MiscField::decode(instr->opcode());
       __ addq(rsp, Immediate(kPointerSize * words));
       break;
     }
@@ skipping 262 matching lines @@
 
 // Assembles boolean materializations after this instruction.
 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
                                         FlagsCondition condition) {
   X64OperandConverter i(this, instr);
   Label done;
 
   // Materialize a full 64-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);
       __ movl(reg, Immediate(0));
       __ jmp(&done, Label::kNear);
     // Fall through.
     case kEqual:
       cc = equal;
@@ skipping 147 matching lines @@
   }
 }
 
 
 void CodeGenerator::AssembleMove(InstructionOperand* source,
                                  InstructionOperand* destination) {
   X64OperandConverter 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);
     if (destination->IsRegister()) {
       __ movq(g.ToRegister(destination), src);
     } else {
       __ movq(g.ToOperand(destination), 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);
       __ movq(dst, src);
     } else {
       // Spill on demand to use a temporary register for memory-to-memory
       // moves.
       Register tmp = kScratchRegister;
       Operand dst = g.ToOperand(destination);
       __ movq(tmp, src);
@@ skipping 18 matching lines @@
       }
       if (destination->IsStackSlot()) {
         __ movq(g.ToOperand(destination), kScratchRegister);
       }
     } else {
       __ movq(kScratchRegister,
               BitCast<uint64_t, double>(g.ToDouble(constant_source)));
       if (destination->IsDoubleRegister()) {
         __ movq(g.ToDoubleRegister(destination), kScratchRegister);
       } else {
-        ASSERT(destination->IsDoubleStackSlot());
+        DCHECK(destination->IsDoubleStackSlot());
         __ movq(g.ToOperand(destination), kScratchRegister);
       }
     }
   } else if (source->IsDoubleRegister()) {
     XMMRegister src = g.ToDoubleRegister(source);
     if (destination->IsDoubleRegister()) {
       XMMRegister dst = g.ToDoubleRegister(destination);
       __ movsd(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 63 matching lines @@
   return *(code->instruction_start() + start_pc) ==
          v8::internal::Assembler::kNopByte;
 }
 
 #endif
 
 #endif
 }
 }
 }  // namespace v8::internal::compiler