Rename ASSERT* to DCHECK*.

src/types.cc

 // Copyright 2014 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.
 
 #include "src/types.h"
 
 #include "src/ostreams.h"
 #include "src/types-inl.h"
 
 namespace v8 {
@@ skipping 115 matching lines @@
   if (IsUint32Double(value)) {
     uint32_t u = FastD2UI(value);
     if (u < 0x40000000u) return kUnsignedSmall;
     if (u < 0x80000000u) {
       return i::SmiValuesAre31Bits() ? kOtherUnsigned31 : kUnsignedSmall;
     }
     return kOtherUnsigned32;
   }
   if (IsInt32Double(value)) {
     int32_t i = FastD2I(value);
-    ASSERT(i < 0);
+    DCHECK(i < 0);
     if (i >= -0x40000000) return kOtherSignedSmall;
     return i::SmiValuesAre31Bits() ? kOtherSigned32 : kOtherSignedSmall;
   }
   return kOtherNumber;
 }
 
 
 template<class Config>
 int TypeImpl<Config>::BitsetType::Lub(i::Map* map) {
   DisallowHeapAllocation no_allocation;
@@ skipping 19 matching lines @@
     case SHORT_EXTERNAL_ASCII_INTERNALIZED_STRING_TYPE:
     case SHORT_EXTERNAL_INTERNALIZED_STRING_WITH_ONE_BYTE_DATA_TYPE:
       return kString;
     case SYMBOL_TYPE:
       return kSymbol;
     case ODDBALL_TYPE: {
       Heap* heap = map->GetHeap();
       if (map == heap->undefined_map()) return kUndefined;
       if (map == heap->null_map()) return kNull;
       if (map == heap->boolean_map()) return kBoolean;
-      ASSERT(map == heap->the_hole_map() ||
+      DCHECK(map == heap->the_hole_map() ||
              map == heap->uninitialized_map() ||
              map == heap->no_interceptor_result_sentinel_map() ||
              map == heap->termination_exception_map() ||
              map == heap->arguments_marker_map());
       return kInternal & kTaggedPtr;
     }
     case HEAP_NUMBER_TYPE:
       return kNumber & kTaggedPtr;
     case JS_VALUE_TYPE:
     case JS_DATE_TYPE:
@@ skipping 110 matching lines @@
   if (this->IsUnion()) {
     UnionHandle unioned = handle(this->AsUnion());
     for (int i = 0; i < unioned->Length(); ++i) {
       if (!unioned->Get(i)->Is(that)) return false;
     }
     return true;
   }
 
   // T <= (T1 \/ ... \/ Tn)  <=>  (T <= T1) \/ ... \/ (T <= Tn)
   // (iff T is not a union)
-  ASSERT(!this->IsUnion() && that->IsUnion());
+  DCHECK(!this->IsUnion() && that->IsUnion());
   UnionHandle unioned = handle(that->AsUnion());
   for (int i = 0; i < unioned->Length(); ++i) {
     if (this->Is(unioned->Get(i))) return true;
     if (this->IsBitset()) break;  // Fast fail, only first field is a bitset.
   }
   return false;
 }
 
 
 template<class Config>
@@ skipping 43 matching lines @@
 
   // T overlaps (T1 \/ ... \/ Tn) <=> (T overlaps T1) \/ ... \/ (T overlaps Tn)
   if (that->IsUnion()) {
     UnionHandle unioned = handle(that->AsUnion());
     for (int i = 0; i < unioned->Length(); ++i) {
       if (this->Maybe(unioned->Get(i))) return true;
     }
     return false;
   }
 
-  ASSERT(!this->IsUnion() && !that->IsUnion());
+  DCHECK(!this->IsUnion() && !that->IsUnion());
   if (this->IsBitset() || that->IsBitset()) {
     return BitsetType::IsInhabited(this->BitsetLub() & that->BitsetLub());
   }
   if (this->IsClass()) {
     return that->IsClass()
         && *this->AsClass()->Map() == *that->AsClass()->Map();
   }
   if (this->IsConstant()) {
     return that->IsConstant()
         && *this->AsConstant()->Value() == *that->AsConstant()->Value();
@@ skipping 20 matching lines @@
   DisallowHeapAllocation no_allocation;
   for (Iterator<i::Object> it = this->Constants(); !it.Done(); it.Advance()) {
     if (*it.Current() == value) return true;
   }
   return BitsetType::New(BitsetType::Lub(value))->Is(this);
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::UnionType::Wellformed() {
-  ASSERT(this->Length() >= 2);
+  DCHECK(this->Length() >= 2);
   for (int i = 0; i < this->Length(); ++i) {
-    ASSERT(!this->Get(i)->IsUnion());
-    if (i > 0) ASSERT(!this->Get(i)->IsBitset());
+    DCHECK(!this->Get(i)->IsUnion());
+    if (i > 0) DCHECK(!this->Get(i)->IsBitset());
     for (int j = 0; j < this->Length(); ++j) {
-      if (i != j) ASSERT(!this->Get(i)->Is(this->Get(j)));
+      if (i != j) DCHECK(!this->Get(i)->Is(this->Get(j)));
     }
   }
   return true;
 }
 
 
 // -----------------------------------------------------------------------------
 // Union and intersection
 
 template<class Config>
@@ skipping 18 matching lines @@
     }
     return type;
   }
   UNREACHABLE();
   return TypeHandle();
 }
 
 
 template<class Config>
 int TypeImpl<Config>::BoundBy(TypeImpl* that) {
-  ASSERT(!this->IsUnion());
+  DCHECK(!this->IsUnion());
   if (that->IsUnion()) {
     UnionType* unioned = that->AsUnion();
     int length = unioned->Length();
     int bitset = BitsetType::kNone;
     for (int i = 0; i < length; ++i) {
       bitset |= BoundBy(unioned->Get(i)->unhandle());
     }
     return bitset;
   } else if (that->IsClass() && this->IsClass() &&
       *this->AsClass()->Map() == *that->AsClass()->Map()) {
     return that->BitsetLub();
   } else if (that->IsConstant() && this->IsConstant() &&
       *this->AsConstant()->Value() == *that->AsConstant()->Value()) {
     return that->AsConstant()->Bound()->AsBitset();
   } else if (that->IsContext() && this->IsContext() && this->Is(that)) {
     return that->AsContext()->Bound()->AsBitset();
   } else if (that->IsArray() && this->IsArray() && this->Is(that)) {
     return that->AsArray()->Bound()->AsBitset();
   } else if (that->IsFunction() && this->IsFunction() && this->Is(that)) {
     return that->AsFunction()->Bound()->AsBitset();
   }
   return that->BitsetGlb();
 }
 
 
 template<class Config>
 int TypeImpl<Config>::IndexInUnion(
     int bound, UnionHandle unioned, int current_size) {
-  ASSERT(!this->IsUnion());
+  DCHECK(!this->IsUnion());
   for (int i = 0; i < current_size; ++i) {
     TypeHandle that = unioned->Get(i);
     if (that->IsBitset()) {
       if ((bound | that->AsBitset()) == that->AsBitset()) return i;
     } else if (that->IsClass() && this->IsClass()) {
       if (*this->AsClass()->Map() == *that->AsClass()->Map()) return i;
     } else if (that->IsConstant() && this->IsConstant()) {
       if (*this->AsConstant()->Value() == *that->AsConstant()->Value())
         return i;
     } else if (that->IsContext() && this->IsContext()) {
@@ skipping 12 matching lines @@
 // Store at result starting at index. Returns updated index.
 template<class Config>
 int TypeImpl<Config>::ExtendUnion(
     UnionHandle result, int size, TypeHandle type,
     TypeHandle other, bool is_intersect, Region* region) {
   int old_size = size;
   if (type->IsUnion()) {
     UnionHandle unioned = handle(type->AsUnion());
     for (int i = 0; i < unioned->Length(); ++i) {
       TypeHandle type_i = unioned->Get(i);
-      ASSERT(i == 0 || !(type_i->IsBitset() || type_i->Is(unioned->Get(0))));
+      DCHECK(i == 0 || !(type_i->IsBitset() || type_i->Is(unioned->Get(0))));
       if (!type_i->IsBitset()) {
         size = ExtendUnion(result, size, type_i, other, is_intersect, region);
       }
     }
   } else if (!type->IsBitset()) {
-    ASSERT(type->IsClass() || type->IsConstant() ||
+    DCHECK(type->IsClass() || type->IsConstant() ||
            type->IsArray() || type->IsFunction() || type->IsContext());
     int inherent_bound = type->InherentBitsetLub();
     int old_bound = type->BitsetLub();
     int other_bound = type->BoundBy(other->unhandle()) & inherent_bound;
     int new_bound =
         is_intersect ? (old_bound & other_bound) : (old_bound | other_bound);
     if (new_bound != BitsetType::kNone) {
       int i = type->IndexInUnion(new_bound, result, old_size);
       if (i == -1) {
         i = size++;
@@ skipping 54 matching lines @@
   // Slow case: may need to produce a Unioned object.
   int size = 0;
   if (!type1->IsBitset()) {
     size += (type1->IsUnion() ? type1->AsUnion()->Length() : 1);
   }
   if (!type2->IsBitset()) {
     size += (type2->IsUnion() ? type2->AsUnion()->Length() : 1);
   }
   int bitset = type1->BitsetGlb() | type2->BitsetGlb();
   if (bitset != BitsetType::kNone) ++size;
-  ASSERT(size >= 1);
+  DCHECK(size >= 1);
 
   UnionHandle unioned = UnionType::New(size, region);
   size = 0;
   if (bitset != BitsetType::kNone) {
     unioned->Set(size++, BitsetType::New(bitset, region));
   }
   size = ExtendUnion(unioned, size, type1, type2, false, region);
   size = ExtendUnion(unioned, size, type2, type1, false, region);
   size = NormalizeUnion(unioned, size, bitset);
 
   if (size == 1) {
     return unioned->Get(0);
   } else {
     unioned->Shrink(size);
-    ASSERT(unioned->Wellformed());
+    DCHECK(unioned->Wellformed());
     return unioned;
   }
 }
 
 
 // Intersection is O(1) on simple bitsets, but O(n*m) on structured unions.
 template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Intersect(
     TypeHandle type1, TypeHandle type2, Region* region) {
   // Fast case: bit sets.
@@ skipping 14 matching lines @@
   // Slow case: may need to produce a Unioned object.
   int size = 0;
   if (!type1->IsBitset()) {
     size += (type1->IsUnion() ? type1->AsUnion()->Length() : 1);
   }
   if (!type2->IsBitset()) {
     size += (type2->IsUnion() ? type2->AsUnion()->Length() : 1);
   }
   int bitset = type1->BitsetGlb() & type2->BitsetGlb();
   if (bitset != BitsetType::kNone) ++size;
-  ASSERT(size >= 1);
+  DCHECK(size >= 1);
 
   UnionHandle unioned = UnionType::New(size, region);
   size = 0;
   if (bitset != BitsetType::kNone) {
     unioned->Set(size++, BitsetType::New(bitset, region));
   }
   size = ExtendUnion(unioned, size, type1, type2, true, region);
   size = ExtendUnion(unioned, size, type2, type1, true, region);
   size = NormalizeUnion(unioned, size, bitset);
 
   if (size == 0) {
     return None(region);
   } else if (size == 1) {
     return unioned->Get(0);
   } else {
     unioned->Shrink(size);
-    ASSERT(unioned->Wellformed());
+    DCHECK(unioned->Wellformed());
     return unioned;
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // Iteration.
 
 template<class Config>
 int TypeImpl<Config>::NumClasses() {
@@ skipping 27 matching lines @@
     return result;
   } else {
     return 0;
   }
 }
 
 
 template<class Config> template<class T>
 typename TypeImpl<Config>::TypeHandle
 TypeImpl<Config>::Iterator<T>::get_type() {
-  ASSERT(!Done());
+  DCHECK(!Done());
   return type_->IsUnion() ? type_->AsUnion()->Get(index_) : type_;
 }
 
 
 // C++ cannot specialise nested templates, so we have to go through this
 // contortion with an auxiliary template to simulate it.
 template<class Config, class T>
 struct TypeImplIteratorAux {
   static bool matches(typename TypeImpl<Config>::TypeHandle type);
   static i::Handle<T> current(typename TypeImpl<Config>::TypeHandle type);
@@ skipping 143 matching lines @@
   os << "(";
   for (int i(ARRAY_SIZE(named_bitsets) - 1); bitset != 0 && i >= 0; --i) {
     int subset = named_bitsets[i];
     if ((bitset & subset) == subset) {
       if (!is_first) os << " | ";
       is_first = false;
       os << Name(subset);
       bitset -= subset;
     }
   }
-  ASSERT(bitset == 0);
+  DCHECK(bitset == 0);
   os << ")";
 }
 
 
 template <class Config>
 void TypeImpl<Config>::PrintTo(OStream& os, PrintDimension dim) {  // NOLINT
   DisallowHeapAllocation no_allocation;
   if (dim != REPRESENTATION_DIM) {
     if (this->IsBitset()) {
       BitsetType::Print(os, SEMANTIC(this->AsBitset()));
@@ skipping 63 matching lines @@
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Object>;
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 } }  // namespace v8::internal