Rename ASSERT* to DCHECK*.

src/assembler.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 165 matching lines @@
     ProbeImpl(cross_compile);
   }
 
   static bool IsSupported(CpuFeature f) {
     return (supported_ & (1u << f)) != 0;
   }
 
   static inline bool SupportsCrankshaft();
 
   static inline unsigned cache_line_size() {
-    ASSERT(cache_line_size_ != 0);
+    DCHECK(cache_line_size_ != 0);
     return cache_line_size_;
   }
 
   static void PrintTarget();
   static void PrintFeatures();
 
   // Flush instruction cache.
   static void FlushICache(void* start, size_t size);
 
  private:
@@ skipping 19 matching lines @@
   enum Distance {
     kNear, kFar
   };
 
   INLINE(Label()) {
     Unuse();
     UnuseNear();
   }
 
   INLINE(~Label()) {
-    ASSERT(!is_linked());
-    ASSERT(!is_near_linked());
+    DCHECK(!is_linked());
+    DCHECK(!is_near_linked());
   }
 
   INLINE(void Unuse()) { pos_ = 0; }
   INLINE(void UnuseNear()) { near_link_pos_ = 0; }
 
   INLINE(bool is_bound() const) { return pos_ <  0; }
   INLINE(bool is_unused() const) { return pos_ == 0 && near_link_pos_ == 0; }
   INLINE(bool is_linked() const) { return pos_ >  0; }
   INLINE(bool is_near_linked() const) { return near_link_pos_ > 0; }
 
   // Returns the position of bound or linked labels. Cannot be used
   // for unused labels.
   int pos() const;
   int near_link_pos() const { return near_link_pos_ - 1; }
 
  private:
   // pos_ encodes both the binding state (via its sign)
   // and the binding position (via its value) of a label.
   //
   // pos_ <  0  bound label, pos() returns the jump target position
   // pos_ == 0  unused label
   // pos_ >  0  linked label, pos() returns the last reference position
   int pos_;
 
   // Behaves like |pos_| in the "> 0" case, but for near jumps to this label.
   int near_link_pos_;
 
   void bind_to(int pos)  {
     pos_ = -pos - 1;
-    ASSERT(is_bound());
+    DCHECK(is_bound());
   }
   void link_to(int pos, Distance distance = kFar) {
     if (distance == kNear) {
       near_link_pos_ = pos + 1;
-      ASSERT(is_near_linked());
+      DCHECK(is_near_linked());
     } else {
       pos_ = pos + 1;
-      ASSERT(is_linked());
+      DCHECK(is_linked());
     }
   }
 
   friend class Assembler;
   friend class Displacement;
   friend class RegExpMacroAssemblerIrregexp;
 
 #if V8_TARGET_ARCH_ARM64
   // On ARM64, the Assembler keeps track of pointers to Labels to resolve
   // branches to distant targets. Copying labels would confuse the Assembler.
@@ skipping 101 matching lines @@
   }
   RelocInfo(byte* pc, double data64)
       : pc_(pc), rmode_(NONE64), data64_(data64), host_(NULL) {
   }
 
   static inline bool IsRealRelocMode(Mode mode) {
     return mode >= FIRST_REAL_RELOC_MODE &&
         mode <= LAST_REAL_RELOC_MODE;
   }
   static inline bool IsPseudoRelocMode(Mode mode) {
-    ASSERT(!IsRealRelocMode(mode));
+    DCHECK(!IsRealRelocMode(mode));
     return mode >= FIRST_PSEUDO_RELOC_MODE &&
         mode <= LAST_PSEUDO_RELOC_MODE;
   }
   static inline bool IsConstructCall(Mode mode) {
     return mode == CONSTRUCT_CALL;
   }
   static inline bool IsCodeTarget(Mode mode) {
     return mode <= LAST_CODE_ENUM;
   }
   static inline bool IsEmbeddedObject(Mode mode) {
@@ skipping 276 matching lines @@
   // iteration iff bit k of mode_mask is set.
   explicit RelocIterator(Code* code, int mode_mask = -1);
   explicit RelocIterator(const CodeDesc& desc, int mode_mask = -1);
 
   // Iteration
   bool done() const { return done_; }
   void next();
 
   // Return pointer valid until next next().
   RelocInfo* rinfo() {
-    ASSERT(!done());
+    DCHECK(!done());
     return &rinfo_;
   }
 
  private:
   // Advance* moves the position before/after reading.
   // *Read* reads from current byte(s) into rinfo_.
   // *Get* just reads and returns info on current byte.
   void Advance(int bytes = 1) { pos_ -= bytes; }
   int AdvanceGetTag();
   int GetExtraTag();
@@ skipping 252 matching lines @@
   // byte NativeRegExpMacroAssembler::word_character_bitmap
   static ExternalReference re_word_character_map();
 
 #endif
 
   // This lets you register a function that rewrites all external references.
   // Used by the ARM simulator to catch calls to external references.
   static void set_redirector(Isolate* isolate,
                              ExternalReferenceRedirector* redirector) {
     // We can't stack them.
-    ASSERT(isolate->external_reference_redirector() == NULL);
+    DCHECK(isolate->external_reference_redirector() == NULL);
     isolate->set_external_reference_redirector(
         reinterpret_cast<ExternalReferenceRedirectorPointer*>(redirector));
   }
 
   static ExternalReference stress_deopt_count(Isolate* isolate);
 
   bool operator==(const ExternalReference& other) const {
     return address_ == other.address_;
   }
 
@@ skipping 152 matching lines @@
 
  private:
   int32_t multiplier_;
   int32_t shift_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ASSEMBLER_H_