Rename ASSERT* to DCHECK*.

src/arm64/utils-arm64.cc

 // 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.
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/arm64/utils-arm64.h"
 
 
 namespace v8 {
 namespace internal {
 
 #define __ assm->
 
 
 int CountLeadingZeros(uint64_t value, int width) {
   // TODO(jbramley): Optimize this for ARM64 hosts.
-  ASSERT((width == 32) || (width == 64));
+  DCHECK((width == 32) || (width == 64));
   int count = 0;
   uint64_t bit_test = 1UL << (width - 1);
   while ((count < width) && ((bit_test & value) == 0)) {
     count++;
     bit_test >>= 1;
   }
   return count;
 }
 
 
 int CountLeadingSignBits(int64_t value, int width) {
   // TODO(jbramley): Optimize this for ARM64 hosts.
-  ASSERT((width == 32) || (width == 64));
+  DCHECK((width == 32) || (width == 64));
   if (value >= 0) {
     return CountLeadingZeros(value, width) - 1;
   } else {
     return CountLeadingZeros(~value, width) - 1;
   }
 }
 
 
 int CountTrailingZeros(uint64_t value, int width) {
   // TODO(jbramley): Optimize this for ARM64 hosts.
-  ASSERT((width == 32) || (width == 64));
+  DCHECK((width == 32) || (width == 64));
   int count = 0;
   while ((count < width) && (((value >> count) & 1) == 0)) {
     count++;
   }
   return count;
 }
 
 
 int CountSetBits(uint64_t value, int width) {
   // TODO(jbramley): Would it be useful to allow other widths? The
   // implementation already supports them.
-  ASSERT((width == 32) || (width == 64));
+  DCHECK((width == 32) || (width == 64));
 
   // Mask out unused bits to ensure that they are not counted.
   value &= (0xffffffffffffffffUL >> (64-width));
 
   // Add up the set bits.
   // The algorithm works by adding pairs of bit fields together iteratively,
   // where the size of each bit field doubles each time.
   // An example for an 8-bit value:
   // Bits:  h  g  f  e  d  c  b  a
   //         \ |   \ |   \ |   \ |
@@ skipping 12 matching lines @@
   return value;
 }
 
 
 uint64_t LargestPowerOf2Divisor(uint64_t value) {
   return value & -value;
 }
 
 
 int MaskToBit(uint64_t mask) {
-  ASSERT(CountSetBits(mask, 64) == 1);
+  DCHECK(CountSetBits(mask, 64) == 1);
   return CountTrailingZeros(mask, 64);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64