Rename ASSERT* to DCHECK*.

src/x64/macro-assembler-x64.h

 // Copyright 2012 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_X64_MACRO_ASSEMBLER_X64_H_
 #define V8_X64_MACRO_ASSEMBLER_X64_H_
 
 #include "src/assembler.h"
 #include "src/frames.h"
 #include "src/globals.h"
@@ skipping 864 matching lines @@
   void PopReturnAddressTo(Register dst) { popq(dst); }
   void Move(Register dst, ExternalReference ext) {
     movp(dst, reinterpret_cast<void*>(ext.address()),
          RelocInfo::EXTERNAL_REFERENCE);
   }
 
   // Loads a pointer into a register with a relocation mode.
   void Move(Register dst, void* ptr, RelocInfo::Mode rmode) {
     // This method must not be used with heap object references. The stored
     // address is not GC safe. Use the handle version instead.
-    ASSERT(rmode > RelocInfo::LAST_GCED_ENUM);
+    DCHECK(rmode > RelocInfo::LAST_GCED_ENUM);
     movp(dst, ptr, rmode);
   }
 
   void Move(Register dst, Handle<Object> value, RelocInfo::Mode rmode) {
     AllowDeferredHandleDereference using_raw_address;
-    ASSERT(!RelocInfo::IsNone(rmode));
-    ASSERT(value->IsHeapObject());
-    ASSERT(!isolate()->heap()->InNewSpace(*value));
+    DCHECK(!RelocInfo::IsNone(rmode));
+    DCHECK(value->IsHeapObject());
+    DCHECK(!isolate()->heap()->InNewSpace(*value));
     movp(dst, reinterpret_cast<void*>(value.location()), rmode);
   }
 
   // Control Flow
   void Jump(Address destination, RelocInfo::Mode rmode);
   void Jump(ExternalReference ext);
   void Jump(const Operand& op);
   void Jump(Handle<Code> code_object, RelocInfo::Mode rmode);
 
   void Call(Address destination, RelocInfo::Mode rmode);
@@ skipping 157 matching lines @@
   }
 
   template<typename Field>
   void DecodeFieldToSmi(Register reg) {
     if (SmiValuesAre32Bits()) {
       andp(reg, Immediate(Field::kMask));
       shlp(reg, Immediate(kSmiShift - Field::kShift));
     } else {
       static const int shift = Field::kShift;
       static const int mask = (Field::kMask >> Field::kShift) << kSmiTagSize;
-      ASSERT(SmiValuesAre31Bits());
-      ASSERT(kSmiShift == kSmiTagSize);
-      ASSERT((mask & 0x80000000u) == 0);
+      DCHECK(SmiValuesAre31Bits());
+      DCHECK(kSmiShift == kSmiTagSize);
+      DCHECK((mask & 0x80000000u) == 0);
       if (shift < kSmiShift) {
         shlp(reg, Immediate(kSmiShift - shift));
       } else if (shift > kSmiShift) {
         sarp(reg, Immediate(shift - kSmiShift));
       }
       andp(reg, Immediate(mask));
     }
   }
 
   // Abort execution if argument is not a number, enabled via --debug-code.
@@ skipping 296 matching lines @@
   // ---------------------------------------------------------------------------
   // Utilities
 
   void Ret();
 
   // Return and drop arguments from stack, where the number of arguments
   // may be bigger than 2^16 - 1.  Requires a scratch register.
   void Ret(int bytes_dropped, Register scratch);
 
   Handle<Object> CodeObject() {
-    ASSERT(!code_object_.is_null());
+    DCHECK(!code_object_.is_null());
     return code_object_;
   }
 
   // Copy length bytes from source to destination.
   // Uses scratch register internally (if you have a low-eight register
   // free, do use it, otherwise kScratchRegister will be used).
   // The min_length is a minimum limit on the value that length will have.
   // The algorithm has some special cases that might be omitted if the string
   // is known to always be long.
   void CopyBytes(Register destination,
@@ skipping 256 matching lines @@
     masm->popfq();                                                           \
   }                                                                          \
   masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_MACRO_ASSEMBLER_X64_H_