Rename ASSERT* to DCHECK*.

src/utils.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_UTILS_H_
 #define V8_UTILS_H_
 
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <cmath>
 
 #include "include/v8.h"
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/base/macros.h"
 #include "src/base/platform/platform.h"
 #include "src/globals.h"
 #include "src/list.h"
 #include "src/vector.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // General helper functions
 
 // X must be a power of 2.  Returns the number of trailing zeros.
 inline int WhichPowerOf2(uint32_t x) {
-  ASSERT(IsPowerOf2(x));
+  DCHECK(IsPowerOf2(x));
   int bits = 0;
 #ifdef DEBUG
   int original_x = x;
 #endif
   if (x >= 0x10000) {
     bits += 16;
     x >>= 16;
   }
   if (x >= 0x100) {
     bits += 8;
     x >>= 8;
   }
   if (x >= 0x10) {
     bits += 4;
     x >>= 4;
   }
   switch (x) {
     default: UNREACHABLE();
     case 8: bits++;  // Fall through.
     case 4: bits++;  // Fall through.
     case 2: bits++;  // Fall through.
     case 1: break;
   }
-  ASSERT_EQ(1 << bits, original_x);
+  DCHECK_EQ(1 << bits, original_x);
   return bits;
   return 0;
 }
 
 
 inline int MostSignificantBit(uint32_t x) {
   static const int msb4[] = {0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4};
   int nibble = 0;
   if (x & 0xffff0000) {
     nibble += 16;
@@ skipping 129 matching lines @@
   // Value for the field with all bits set.
   static const T kMax = static_cast<T>((1U << size) - 1);
 
   // Tells whether the provided value fits into the bit field.
   static bool is_valid(T value) {
     return (static_cast<U>(value) & ~static_cast<U>(kMax)) == 0;
   }
 
   // Returns a type U with the bit field value encoded.
   static U encode(T value) {
-    ASSERT(is_valid(value));
+    DCHECK(is_valid(value));
     return static_cast<U>(value) << shift;
   }
 
   // Returns a type U with the bit field value updated.
   static U update(U previous, T value) {
     return (previous & ~kMask) | encode(value);
   }
 
   // Extracts the bit field from the value.
   static T decode(U value) {
@@ skipping 146 matching lines @@
 };
 
 
 // Locally scoped access to a static resource.
 template <typename T>
 class Access {
  public:
   explicit Access(StaticResource<T>* resource)
     : resource_(resource)
     , instance_(&resource->instance_) {
-    ASSERT(!resource->is_reserved_);
+    DCHECK(!resource->is_reserved_);
     resource->is_reserved_ = true;
   }
 
   ~Access() {
     resource_->is_reserved_ = false;
     resource_ = NULL;
     instance_ = NULL;
   }
 
   T* value()  { return instance_; }
   T* operator -> ()  { return instance_; }
 
  private:
   StaticResource<T>* resource_;
   T* instance_;
 };
 
 
 // A pointer that can only be set once and doesn't allow NULL values.
 template<typename T>
 class SetOncePointer {
  public:
   SetOncePointer() : pointer_(NULL) { }
 
   bool is_set() const { return pointer_ != NULL; }
 
   T* get() const {
-    ASSERT(pointer_ != NULL);
+    DCHECK(pointer_ != NULL);
     return pointer_;
   }
 
   void set(T* value) {
-    ASSERT(pointer_ == NULL && value != NULL);
+    DCHECK(pointer_ == NULL && value != NULL);
     pointer_ = value;
   }
 
  private:
   T* pointer_;
 };
 
 
 template <typename T, int kSize>
 class EmbeddedVector : public Vector<T> {
@@ skipping 59 matching lines @@
     current_chunk_[index_] = value;
     index_++;
     size_++;
   }
 
   // Add a block of contiguous elements and return a Vector backed by the
   // memory area.
   // A basic Collector will keep this vector valid as long as the Collector
   // is alive.
   inline Vector<T> AddBlock(int size, T initial_value) {
-    ASSERT(size > 0);
+    DCHECK(size > 0);
     if (size > current_chunk_.length() - index_) {
       Grow(size);
     }
     T* position = current_chunk_.start() + index_;
     index_ += size;
     size_ += size;
     for (int i = 0; i < size; i++) {
       position[i] = initial_value;
     }
     return Vector<T>(position, size);
@@ skipping 13 matching lines @@
     size_ += source.length();
     for (int i = 0; i < source.length(); i++) {
       position[i] = source[i];
     }
     return Vector<T>(position, source.length());
   }
 
 
   // Write the contents of the collector into the provided vector.
   void WriteTo(Vector<T> destination) {
-    ASSERT(size_ <= destination.length());
+    DCHECK(size_ <= destination.length());
     int position = 0;
     for (int i = 0; i < chunks_.length(); i++) {
       Vector<T> chunk = chunks_.at(i);
       for (int j = 0; j < chunk.length(); j++) {
         destination[position] = chunk[j];
         position++;
       }
     }
     for (int i = 0; i < index_; i++) {
       destination[position] = current_chunk_[i];
@@ skipping 19 matching lines @@
 
  protected:
   static const int kMinCapacity = 16;
   List<Vector<T> > chunks_;
   Vector<T> current_chunk_;  // Block of memory currently being written into.
   int index_;  // Current index in current chunk.
   int size_;  // Total number of elements in collector.
 
   // Creates a new current chunk, and stores the old chunk in the chunks_ list.
   void Grow(int min_capacity) {
-    ASSERT(growth_factor > 1);
+    DCHECK(growth_factor > 1);
     int new_capacity;
     int current_length = current_chunk_.length();
     if (current_length < kMinCapacity) {
       // The collector started out as empty.
       new_capacity = min_capacity * growth_factor;
       if (new_capacity < kMinCapacity) new_capacity = kMinCapacity;
     } else {
       int growth = current_length * (growth_factor - 1);
       if (growth > max_growth) {
         growth = max_growth;
       }
       new_capacity = current_length + growth;
       if (new_capacity < min_capacity) {
         new_capacity = min_capacity + growth;
       }
     }
     NewChunk(new_capacity);
-    ASSERT(index_ + min_capacity <= current_chunk_.length());
+    DCHECK(index_ + min_capacity <= current_chunk_.length());
   }
 
   // Before replacing the current chunk, give a subclass the option to move
   // some of the current data into the new chunk. The function may update
   // the current index_ value to represent data no longer in the current chunk.
   // Returns the initial index of the new chunk (after copied data).
   virtual void NewChunk(int new_capacity)  {
     Vector<T> new_chunk = Vector<T>::New(new_capacity);
     if (index_ > 0) {
       chunks_.Add(current_chunk_.SubVector(0, index_));
@@ skipping 18 matching lines @@
 template <typename T, int growth_factor = 2, int max_growth = 1 * MB>
 class SequenceCollector : public Collector<T, growth_factor, max_growth> {
  public:
   explicit SequenceCollector(int initial_capacity)
       : Collector<T, growth_factor, max_growth>(initial_capacity),
         sequence_start_(kNoSequence) { }
 
   virtual ~SequenceCollector() {}
 
   void StartSequence() {
-    ASSERT(sequence_start_ == kNoSequence);
+    DCHECK(sequence_start_ == kNoSequence);
     sequence_start_ = this->index_;
   }
 
   Vector<T> EndSequence() {
-    ASSERT(sequence_start_ != kNoSequence);
+    DCHECK(sequence_start_ != kNoSequence);
     int sequence_start = sequence_start_;
     sequence_start_ = kNoSequence;
     if (sequence_start == this->index_) return Vector<T>();
     return this->current_chunk_.SubVector(sequence_start, this->index_);
   }
 
   // Drops the currently added sequence, and all collected elements in it.
   void DropSequence() {
-    ASSERT(sequence_start_ != kNoSequence);
+    DCHECK(sequence_start_ != kNoSequence);
     int sequence_length = this->index_ - sequence_start_;
     this->index_ = sequence_start_;
     this->size_ -= sequence_length;
     sequence_start_ = kNoSequence;
   }
 
   virtual void Reset() {
     sequence_start_ = kNoSequence;
     this->Collector<T, growth_factor, max_growth>::Reset();
   }
 
  private:
   static const int kNoSequence = -1;
   int sequence_start_;
 
   // Move the currently active sequence to the new chunk.
   virtual void NewChunk(int new_capacity) {
     if (sequence_start_ == kNoSequence) {
       // Fall back on default behavior if no sequence has been started.
       this->Collector<T, growth_factor, max_growth>::NewChunk(new_capacity);
       return;
     }
     int sequence_length = this->index_ - sequence_start_;
     Vector<T> new_chunk = Vector<T>::New(sequence_length + new_capacity);
-    ASSERT(sequence_length < new_chunk.length());
+    DCHECK(sequence_length < new_chunk.length());
     for (int i = 0; i < sequence_length; i++) {
       new_chunk[i] = this->current_chunk_[sequence_start_ + i];
     }
     if (sequence_start_ > 0) {
       this->chunks_.Add(this->current_chunk_.SubVector(0, sequence_start_));
     } else {
       this->current_chunk_.Dispose();
     }
     this->current_chunk_ = new_chunk;
     this->index_ = sequence_length;
@@ skipping 26 matching lines @@
     int r = static_cast<int>(*lhs) - static_cast<int>(*rhs);
     if (r != 0) return r;
     ++lhs;
     ++rhs;
   }
   return 0;
 }
 
 template<typename lchar, typename rchar>
 inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) {
-  ASSERT(sizeof(lchar) <= 2);
-  ASSERT(sizeof(rchar) <= 2);
+  DCHECK(sizeof(lchar) <= 2);
+  DCHECK(sizeof(rchar) <= 2);
   if (sizeof(lchar) == 1) {
     if (sizeof(rchar) == 1) {
       return CompareCharsUnsigned(reinterpret_cast<const uint8_t*>(lhs),
                                   reinterpret_cast<const uint8_t*>(rhs),
                                   chars);
     } else {
       return CompareCharsUnsigned(reinterpret_cast<const uint8_t*>(lhs),
                                   reinterpret_cast<const uint16_t*>(rhs),
                                   chars);
     }
   } else {
     if (sizeof(rchar) == 1) {
       return CompareCharsUnsigned(reinterpret_cast<const uint16_t*>(lhs),
                                   reinterpret_cast<const uint8_t*>(rhs),
                                   chars);
     } else {
       return CompareCharsUnsigned(reinterpret_cast<const uint16_t*>(lhs),
                                   reinterpret_cast<const uint16_t*>(rhs),
                                   chars);
     }
   }
 }
 
 
 // Calculate 10^exponent.
 inline int TenToThe(int exponent) {
-  ASSERT(exponent <= 9);
-  ASSERT(exponent >= 1);
+  DCHECK(exponent <= 9);
+  DCHECK(exponent >= 1);
   int answer = 10;
   for (int i = 1; i < exponent; i++) answer *= 10;
   return answer;
 }
 
 
 // The type-based aliasing rule allows the compiler to assume that pointers of
 // different types (for some definition of different) never alias each other.
 // Thus the following code does not work:
 //
@@ skipping 49 matching lines @@
 }
 
 
 template<typename ElementType, int NumElements>
 class EmbeddedContainer {
  public:
   EmbeddedContainer() : elems_() { }
 
   int length() const { return NumElements; }
   const ElementType& operator[](int i) const {
-    ASSERT(i < length());
+    DCHECK(i < length());
     return elems_[i];
   }
   ElementType& operator[](int i) {
-    ASSERT(i < length());
+    DCHECK(i < length());
     return elems_[i];
   }
 
  private:
   ElementType elems_[NumElements];
 };
 
 
 template<typename ElementType>
 class EmbeddedContainer<ElementType, 0> {
@@ skipping 25 matching lines @@
 
   SimpleStringBuilder(char* buffer, int size)
       : buffer_(buffer, size), position_(0) { }
 
   ~SimpleStringBuilder() { if (!is_finalized()) Finalize(); }
 
   int size() const { return buffer_.length(); }
 
   // Get the current position in the builder.
   int position() const {
-    ASSERT(!is_finalized());
+    DCHECK(!is_finalized());
     return position_;
   }
 
   // Reset the position.
   void Reset() { position_ = 0; }
 
   // Add a single character to the builder. It is not allowed to add
   // 0-characters; use the Finalize() method to terminate the string
   // instead.
   void AddCharacter(char c) {
-    ASSERT(c != '\0');
-    ASSERT(!is_finalized() && position_ < buffer_.length());
+    DCHECK(c != '\0');
+    DCHECK(!is_finalized() && position_ < buffer_.length());
     buffer_[position_++] = c;
   }
 
   // Add an entire string to the builder. Uses strlen() internally to
   // compute the length of the input string.
   void AddString(const char* s);
 
   // Add the first 'n' characters of the given string 's' to the
   // builder. The input string must have enough characters.
   void AddSubstring(const char* s, int n);
@@ skipping 38 matching lines @@
   void Intersect(const EnumSet& set) { bits_ &= set.bits_; }
   T ToIntegral() const { return bits_; }
   bool operator==(const EnumSet& set) { return bits_ == set.bits_; }
   bool operator!=(const EnumSet& set) { return bits_ != set.bits_; }
   EnumSet<E, T> operator|(const EnumSet& set) const {
     return EnumSet<E, T>(bits_ | set.bits_);
   }
 
  private:
   T Mask(E element) const {
-    // The strange typing in ASSERT is necessary to avoid stupid warnings, see:
+    // The strange typing in DCHECK is necessary to avoid stupid warnings, see:
     // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43680
-    ASSERT(static_cast<int>(element) < static_cast<int>(sizeof(T) * CHAR_BIT));
+    DCHECK(static_cast<int>(element) < static_cast<int>(sizeof(T) * CHAR_BIT));
     return static_cast<T>(1) << element;
   }
 
   T bits_;
 };
 
 // Bit field extraction.
 inline uint32_t unsigned_bitextract_32(int msb, int lsb, uint32_t x) {
   return (x >> lsb) & ((1 << (1 + msb - lsb)) - 1);
 }
 
 inline uint64_t unsigned_bitextract_64(int msb, int lsb, uint64_t x) {
   return (x >> lsb) & ((static_cast<uint64_t>(1) << (1 + msb - lsb)) - 1);
 }
 
 inline int32_t signed_bitextract_32(int msb, int lsb, int32_t x) {
   return (x << (31 - msb)) >> (lsb + 31 - msb);
 }
 
 inline int signed_bitextract_64(int msb, int lsb, int x) {
   // TODO(jbramley): This is broken for big bitfields.
   return (x << (63 - msb)) >> (lsb + 63 - msb);
 }
 
 // Check number width.
 inline bool is_intn(int64_t x, unsigned n) {
-  ASSERT((0 < n) && (n < 64));
+  DCHECK((0 < n) && (n < 64));
   int64_t limit = static_cast<int64_t>(1) << (n - 1);
   return (-limit <= x) && (x < limit);
 }
 
 inline bool is_uintn(int64_t x, unsigned n) {
-  ASSERT((0 < n) && (n < (sizeof(x) * kBitsPerByte)));
+  DCHECK((0 < n) && (n < (sizeof(x) * kBitsPerByte)));
   return !(x >> n);
 }
 
 template <class T>
 inline T truncate_to_intn(T x, unsigned n) {
-  ASSERT((0 < n) && (n < (sizeof(x) * kBitsPerByte)));
+  DCHECK((0 < n) && (n < (sizeof(x) * kBitsPerByte)));
   return (x & ((static_cast<T>(1) << n) - 1));
 }
 
 #define INT_1_TO_63_LIST(V)                                                    \
 V(1)  V(2)  V(3)  V(4)  V(5)  V(6)  V(7)  V(8)                                 \
 V(9)  V(10) V(11) V(12) V(13) V(14) V(15) V(16)                                \
 V(17) V(18) V(19) V(20) V(21) V(22) V(23) V(24)                                \
 V(25) V(26) V(27) V(28) V(29) V(30) V(31) V(32)                                \
 V(33) V(34) V(35) V(36) V(37) V(38) V(39) V(40)                                \
 V(41) V(42) V(43) V(44) V(45) V(46) V(47) V(48)                                \
@@ skipping 185 matching lines @@
 // ----------------------------------------------------------------------------
 // Memory
 
 // Copies words from |src| to |dst|. The data spans must not overlap.
 template <typename T>
 inline void CopyWords(T* dst, const T* src, size_t num_words) {
   STATIC_ASSERT(sizeof(T) == kPointerSize);
   // TODO(mvstanton): disabled because mac builds are bogus failing on this
   // assert. They are doing a signed comparison. Investigate in
   // the morning.
-  // ASSERT(Min(dst, const_cast<T*>(src)) + num_words <=
+  // DCHECK(Min(dst, const_cast<T*>(src)) + num_words <=
   //       Max(dst, const_cast<T*>(src)));
-  ASSERT(num_words > 0);
+  DCHECK(num_words > 0);
 
   // Use block copying MemCopy if the segment we're copying is
   // enough to justify the extra call/setup overhead.
   static const size_t kBlockCopyLimit = 16;
 
   if (num_words < kBlockCopyLimit) {
     do {
       num_words--;
       *dst++ = *src++;
     } while (num_words > 0);
   } else {
     MemCopy(dst, src, num_words * kPointerSize);
   }
 }
 
 
 // Copies words from |src| to |dst|. No restrictions.
 template <typename T>
 inline void MoveWords(T* dst, const T* src, size_t num_words) {
   STATIC_ASSERT(sizeof(T) == kPointerSize);
-  ASSERT(num_words > 0);
+  DCHECK(num_words > 0);
 
   // Use block copying MemCopy if the segment we're copying is
   // enough to justify the extra call/setup overhead.
   static const size_t kBlockCopyLimit = 16;
 
   if (num_words < kBlockCopyLimit &&
       ((dst < src) || (dst >= (src + num_words * kPointerSize)))) {
     T* end = dst + num_words;
     do {
       num_words--;
       *dst++ = *src++;
     } while (num_words > 0);
   } else {
     MemMove(dst, src, num_words * kPointerSize);
   }
 }
 
 
 // Copies data from |src| to |dst|.  The data spans must not overlap.
 template <typename T>
 inline void CopyBytes(T* dst, const T* src, size_t num_bytes) {
   STATIC_ASSERT(sizeof(T) == 1);
-  ASSERT(Min(dst, const_cast<T*>(src)) + num_bytes <=
+  DCHECK(Min(dst, const_cast<T*>(src)) + num_bytes <=
          Max(dst, const_cast<T*>(src)));
   if (num_bytes == 0) return;
 
   // Use block copying MemCopy if the segment we're copying is
   // enough to justify the extra call/setup overhead.
   static const int kBlockCopyLimit = kMinComplexMemCopy;
 
   if (num_bytes < static_cast<size_t>(kBlockCopyLimit)) {
     do {
       num_bytes--;
@@ skipping 90 matching lines @@
 INLINE(void CopyCharsUnsigned(uint8_t* dest, const uint8_t* src, int chars));
 INLINE(void CopyCharsUnsigned(uint16_t* dest, const uint16_t* src, int chars));
 #endif
 
 // Copy from ASCII/16bit chars to ASCII/16bit chars.
 template <typename sourcechar, typename sinkchar>
 INLINE(void CopyChars(sinkchar* dest, const sourcechar* src, int chars));
 
 template<typename sourcechar, typename sinkchar>
 void CopyChars(sinkchar* dest, const sourcechar* src, int chars) {
-  ASSERT(sizeof(sourcechar) <= 2);
-  ASSERT(sizeof(sinkchar) <= 2);
+  DCHECK(sizeof(sourcechar) <= 2);
+  DCHECK(sizeof(sinkchar) <= 2);
   if (sizeof(sinkchar) == 1) {
     if (sizeof(sourcechar) == 1) {
       CopyCharsUnsigned(reinterpret_cast<uint8_t*>(dest),
                         reinterpret_cast<const uint8_t*>(src),
                         chars);
     } else {
       CopyCharsUnsigned(reinterpret_cast<uint8_t*>(dest),
                         reinterpret_cast<const uint16_t*>(src),
                         chars);
     }
@@ skipping 14 matching lines @@
 void CopyCharsUnsigned(sinkchar* dest, const sourcechar* src, int chars) {
   sinkchar* limit = dest + chars;
 #ifdef V8_HOST_CAN_READ_UNALIGNED
   if (sizeof(*dest) == sizeof(*src)) {
     if (chars >= static_cast<int>(kMinComplexMemCopy / sizeof(*dest))) {
       MemCopy(dest, src, chars * sizeof(*dest));
       return;
     }
     // Number of characters in a uintptr_t.
     static const int kStepSize = sizeof(uintptr_t) / sizeof(*dest);  // NOLINT
-    ASSERT(dest + kStepSize > dest);  // Check for overflow.
+    DCHECK(dest + kStepSize > dest);  // Check for overflow.
     while (dest + kStepSize <= limit) {
       *reinterpret_cast<uintptr_t*>(dest) =
           *reinterpret_cast<const uintptr_t*>(src);
       dest += kStepSize;
       src += kStepSize;
     }
   }
 #endif
   while (dest < limit) {
     *dest++ = static_cast<sinkchar>(*src++);
@@ skipping 159 matching lines @@
   }
 
   *index = result;
   return true;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_