Rename ASSERT* to DCHECK*.

src/safepoint-table.h

 // Copyright 2011 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_SAFEPOINT_TABLE_H_
 #define V8_SAFEPOINT_TABLE_H_
 
 #include "src/allocation.h"
 #include "src/heap.h"
 #include "src/v8memory.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 struct Register;
 
 class SafepointEntry BASE_EMBEDDED {
  public:
   SafepointEntry() : info_(0), bits_(NULL) {}
 
   SafepointEntry(unsigned info, uint8_t* bits) : info_(info), bits_(bits) {
-    ASSERT(is_valid());
+    DCHECK(is_valid());
   }
 
   bool is_valid() const { return bits_ != NULL; }
 
   bool Equals(const SafepointEntry& other) const {
     return info_ == other.info_ && bits_ == other.bits_;
   }
 
   void Reset() {
     info_ = 0;
     bits_ = NULL;
   }
 
   int deoptimization_index() const {
-    ASSERT(is_valid());
+    DCHECK(is_valid());
     return DeoptimizationIndexField::decode(info_);
   }
 
   static const int kArgumentsFieldBits = 3;
   static const int kSaveDoublesFieldBits = 1;
   static const int kDeoptIndexBits =
       32 - kArgumentsFieldBits - kSaveDoublesFieldBits;
   class DeoptimizationIndexField:
     public BitField<int, 0, kDeoptIndexBits> {};  // NOLINT
   class ArgumentsField:
     public BitField<unsigned,
                     kDeoptIndexBits,
                     kArgumentsFieldBits> {};  // NOLINT
   class SaveDoublesField:
     public BitField<bool,
                     kDeoptIndexBits + kArgumentsFieldBits,
                     kSaveDoublesFieldBits> { }; // NOLINT
 
   int argument_count() const {
-    ASSERT(is_valid());
+    DCHECK(is_valid());
     return ArgumentsField::decode(info_);
   }
 
   bool has_doubles() const {
-    ASSERT(is_valid());
+    DCHECK(is_valid());
     return SaveDoublesField::decode(info_);
   }
 
   uint8_t* bits() {
-    ASSERT(is_valid());
+    DCHECK(is_valid());
     return bits_;
   }
 
   bool HasRegisters() const;
   bool HasRegisterAt(int reg_index) const;
 
  private:
   unsigned info_;
   uint8_t* bits_;
 };
 
 
 class SafepointTable BASE_EMBEDDED {
  public:
   explicit SafepointTable(Code* code);
 
   int size() const {
     return kHeaderSize +
            (length_ * (kPcAndDeoptimizationIndexSize + entry_size_)); }
   unsigned length() const { return length_; }
   unsigned entry_size() const { return entry_size_; }
 
   unsigned GetPcOffset(unsigned index) const {
-    ASSERT(index < length_);
+    DCHECK(index < length_);
     return Memory::uint32_at(GetPcOffsetLocation(index));
   }
 
   SafepointEntry GetEntry(unsigned index) const {
-    ASSERT(index < length_);
+    DCHECK(index < length_);
     unsigned info = Memory::uint32_at(GetInfoLocation(index));
     uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_));
     return SafepointEntry(info, bits);
   }
 
   // Returns the entry for the given pc.
   SafepointEntry FindEntry(Address pc) const;
 
   void PrintEntry(unsigned index, OStream& os) const;  // NOLINT
 
@@ skipping 117 matching lines @@
   int last_lazy_safepoint_;
 
   Zone* zone_;
 
   DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SAFEPOINT_TABLE_H_