Rename ASSERT* to DCHECK*.

src/arm64/lithium-arm64.h

 // 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.
 
 #ifndef V8_ARM64_LITHIUM_ARM64_H_
 #define V8_ARM64_LITHIUM_ARM64_H_
 
 #include "src/hydrogen.h"
 #include "src/lithium.h"
 #include "src/lithium-allocator.h"
@@ skipping 168 matching lines @@
 
 #define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic)                        \
   virtual Opcode opcode() const V8_FINAL V8_OVERRIDE {                      \
     return LInstruction::k##type;                                           \
   }                                                                         \
   virtual void CompileToNative(LCodeGen* generator) V8_FINAL V8_OVERRIDE;   \
   virtual const char* Mnemonic() const V8_FINAL V8_OVERRIDE {               \
     return mnemonic;                                                        \
   }                                                                         \
   static L##type* cast(LInstruction* instr) {                               \
-    ASSERT(instr->Is##type());                                              \
+    DCHECK(instr->Is##type());                                              \
     return reinterpret_cast<L##type*>(instr);                               \
   }
 
 
 #define DECLARE_HYDROGEN_ACCESSOR(type)           \
   H##type* hydrogen() const {                     \
     return H##type::cast(this->hydrogen_value()); \
   }
 
 
@@ skipping 184 matching lines @@
     parallel_moves_[BEFORE] = NULL;
     parallel_moves_[START] = NULL;
     parallel_moves_[END] = NULL;
     parallel_moves_[AFTER] = NULL;
   }
 
   // Can't use the DECLARE-macro here because of sub-classes.
   virtual bool IsGap() const V8_OVERRIDE { return true; }
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
   static LGap* cast(LInstruction* instr) {
-    ASSERT(instr->IsGap());
+    DCHECK(instr->IsGap());
     return reinterpret_cast<LGap*>(instr);
   }
 
   bool IsRedundant() const;
 
   HBasicBlock* block() const { return block_; }
 
   enum InnerPosition {
     BEFORE,
     START,
@@ skipping 1116 matching lines @@
 };
 
 
 class LCallWithDescriptor V8_FINAL : public LTemplateResultInstruction<1> {
  public:
   LCallWithDescriptor(const InterfaceDescriptor* descriptor,
                       const ZoneList<LOperand*>& operands,
                       Zone* zone)
     : descriptor_(descriptor),
       inputs_(descriptor->GetRegisterParameterCount() + 1, zone) {
-    ASSERT(descriptor->GetRegisterParameterCount() + 1 == operands.length());
+    DCHECK(descriptor->GetRegisterParameterCount() + 1 == operands.length());
     inputs_.AddAll(operands, zone);
   }
 
   LOperand* target() const { return inputs_[0]; }
 
   const InterfaceDescriptor* descriptor() { return descriptor_; }
 
  private:
   DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
   DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor)
@@ skipping 799 matching lines @@
     inputs_[2] = parameter_count;
   }
 
   LOperand* value() { return inputs_[0]; }
   LOperand* parameter_count() { return inputs_[2]; }
 
   bool has_constant_parameter_count() {
     return parameter_count()->IsConstantOperand();
   }
   LConstantOperand* constant_parameter_count() {
-    ASSERT(has_constant_parameter_count());
+    DCHECK(has_constant_parameter_count());
     return LConstantOperand::cast(parameter_count());
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Return, "return")
 };
 
 
 class LSeqStringGetChar V8_FINAL : public LTemplateInstruction<1, 2, 1> {
  public:
   LSeqStringGetChar(LOperand* string,
@@ skipping 122 matching lines @@
     this->elements()->PrintTo(stream);
     stream->Add("[");
     this->key()->PrintTo(stream);
     if (this->base_offset() != 0) {
       stream->Add(" + %d] <-", this->base_offset());
     } else {
       stream->Add("] <- ");
     }
 
     if (this->value() == NULL) {
-      ASSERT(hydrogen()->IsConstantHoleStore() &&
+      DCHECK(hydrogen()->IsConstantHoleStore() &&
              hydrogen()->value()->representation().IsDouble());
       stream->Add("<the hole(nan)>");
     } else {
       this->value()->PrintTo(stream);
     }
   }
 
   DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
 };
 
@@ skipping 708 matching lines @@
   void AddInstruction(LInstruction* instr, HInstruction* current);
   void DoBasicBlock(HBasicBlock* block);
 
   int JSShiftAmountFromHConstant(HValue* constant) {
     return HConstant::cast(constant)->Integer32Value() & 0x1f;
   }
   bool LikelyFitsImmField(HInstruction* instr, int imm) {
     if (instr->IsAdd() || instr->IsSub()) {
       return Assembler::IsImmAddSub(imm) || Assembler::IsImmAddSub(-imm);
     } else {
-      ASSERT(instr->IsBitwise());
+      DCHECK(instr->IsBitwise());
       unsigned unused_n, unused_imm_s, unused_imm_r;
       return Assembler::IsImmLogical(imm, kWRegSizeInBits,
                                      &unused_n, &unused_imm_s, &unused_imm_r);
     }
   }
 
   // Indicates if a sequence of the form
   //   lsl x8, x9, #imm
   //   add x0, x1, x8
   // can be replaced with:
@@ skipping 28 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_LITHIUM_ARM64_H_