Rename ASSERT* to DCHECK*.

src/diy-fp.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_DIY_FP_H_
 #define V8_DIY_FP_H_
 
 namespace v8 {
 namespace internal {
 
 // This "Do It Yourself Floating Point" class implements a floating-point number
 // with a uint64 significand and an int exponent. Normalized DiyFp numbers will
 // have the most significant bit of the significand set.
 // Multiplication and Subtraction do not normalize their results.
 // DiyFp are not designed to contain special doubles (NaN and Infinity).
 class DiyFp {
  public:
   static const int kSignificandSize = 64;
 
   DiyFp() : f_(0), e_(0) {}
   DiyFp(uint64_t f, int e) : f_(f), e_(e) {}
 
   // this = this - other.
   // The exponents of both numbers must be the same and the significand of this
   // must be bigger than the significand of other.
   // The result will not be normalized.
   void Subtract(const DiyFp& other) {
-    ASSERT(e_ == other.e_);
-    ASSERT(f_ >= other.f_);
+    DCHECK(e_ == other.e_);
+    DCHECK(f_ >= other.f_);
     f_ -= other.f_;
   }
 
   // Returns a - b.
   // The exponents of both numbers must be the same and this must be bigger
   // than other. The result will not be normalized.
   static DiyFp Minus(const DiyFp& a, const DiyFp& b) {
     DiyFp result = a;
     result.Subtract(b);
     return result;
   }
 
 
   // this = this * other.
   void Multiply(const DiyFp& other);
 
   // returns a * b;
   static DiyFp Times(const DiyFp& a, const DiyFp& b) {
     DiyFp result = a;
     result.Multiply(b);
     return result;
   }
 
   void Normalize() {
-    ASSERT(f_ != 0);
+    DCHECK(f_ != 0);
     uint64_t f = f_;
     int e = e_;
 
     // This method is mainly called for normalizing boundaries. In general
     // boundaries need to be shifted by 10 bits. We thus optimize for this case.
     const uint64_t k10MSBits = static_cast<uint64_t>(0x3FF) << 54;
     while ((f & k10MSBits) == 0) {
       f <<= 10;
       e -= 10;
     }
@@ skipping 20 matching lines @@
  private:
   static const uint64_t kUint64MSB = static_cast<uint64_t>(1) << 63;
 
   uint64_t f_;
   int e_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_DIY_FP_H_