Rename ASSERT* to DCHECK*.

src/hydrogen-instructions.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/double.h"
 #include "src/factory.h"
 #include "src/hydrogen-infer-representation.h"
 #include "src/property-details-inl.h"
@@ skipping 23 matching lines @@
 
 #define DEFINE_COMPILE(type)                                         \
   LInstruction* H##type::CompileToLithium(LChunkBuilder* builder) {  \
     return builder->Do##type(this);                                  \
   }
 HYDROGEN_CONCRETE_INSTRUCTION_LIST(DEFINE_COMPILE)
 #undef DEFINE_COMPILE
 
 
 Isolate* HValue::isolate() const {
-  ASSERT(block() != NULL);
+  DCHECK(block() != NULL);
   return block()->isolate();
 }
 
 
 void HValue::AssumeRepresentation(Representation r) {
   if (CheckFlag(kFlexibleRepresentation)) {
     ChangeRepresentation(r);
     // The representation of the value is dictated by type feedback and
     // will not be changed later.
     ClearFlag(kFlexibleRepresentation);
   }
 }
 
 
 void HValue::InferRepresentation(HInferRepresentationPhase* h_infer) {
-  ASSERT(CheckFlag(kFlexibleRepresentation));
+  DCHECK(CheckFlag(kFlexibleRepresentation));
   Representation new_rep = RepresentationFromInputs();
   UpdateRepresentation(new_rep, h_infer, "inputs");
   new_rep = RepresentationFromUses();
   UpdateRepresentation(new_rep, h_infer, "uses");
   if (representation().IsSmi() && HasNonSmiUse()) {
     UpdateRepresentation(
         Representation::Integer32(), h_infer, "use requirements");
   }
 }
 
@@ skipping 214 matching lines @@
   if (lower_ > upper_) {
     int32_t tmp = lower_;
     lower_ = upper_;
     upper_ = tmp;
   }
 }
 
 
 #ifdef DEBUG
 void Range::Verify() const {
-  ASSERT(lower_ <= upper_);
+  DCHECK(lower_ <= upper_);
 }
 #endif
 
 
 bool Range::MulAndCheckOverflow(const Representation& r, Range* other) {
   bool may_overflow = false;
   int v1 = MulWithoutOverflow(r, lower_, other->lower(), &may_overflow);
   int v2 = MulWithoutOverflow(r, lower_, other->upper(), &may_overflow);
   int v3 = MulWithoutOverflow(r, upper_, other->lower(), &may_overflow);
   int v4 = MulWithoutOverflow(r, upper_, other->upper(), &may_overflow);
@@ skipping 108 matching lines @@
 bool HValue::Equals(HValue* other) {
   if (other->opcode() != opcode()) return false;
   if (!other->representation().Equals(representation())) return false;
   if (!other->type_.Equals(type_)) return false;
   if (other->flags() != flags()) return false;
   if (OperandCount() != other->OperandCount()) return false;
   for (int i = 0; i < OperandCount(); ++i) {
     if (OperandAt(i)->id() != other->OperandAt(i)->id()) return false;
   }
   bool result = DataEquals(other);
-  ASSERT(!result || Hashcode() == other->Hashcode());
+  DCHECK(!result || Hashcode() == other->Hashcode());
   return result;
 }
 
 
 intptr_t HValue::Hashcode() {
   intptr_t result = opcode();
   int count = OperandCount();
   for (int i = 0; i < count; ++i) {
     result = result * 19 + OperandAt(i)->id() + (result >> 7);
   }
@@ skipping 51 matching lines @@
   if (other != NULL) ReplaceAllUsesWith(other);
   Kill();
   DeleteFromGraph();
 }
 
 
 void HValue::ReplaceAllUsesWith(HValue* other) {
   while (use_list_ != NULL) {
     HUseListNode* list_node = use_list_;
     HValue* value = list_node->value();
-    ASSERT(!value->block()->IsStartBlock());
+    DCHECK(!value->block()->IsStartBlock());
     value->InternalSetOperandAt(list_node->index(), other);
     use_list_ = list_node->tail();
     list_node->set_tail(other->use_list_);
     other->use_list_ = list_node;
   }
 }
 
 
 void HValue::Kill() {
   // Instead of going through the entire use list of each operand, we only
   // check the first item in each use list and rely on the tail() method to
   // skip dead items, removing them lazily next time we traverse the list.
   SetFlag(kIsDead);
   for (int i = 0; i < OperandCount(); ++i) {
     HValue* operand = OperandAt(i);
     if (operand == NULL) continue;
     HUseListNode* first = operand->use_list_;
     if (first != NULL && first->value()->CheckFlag(kIsDead)) {
       operand->use_list_ = first->tail();
     }
   }
 }
 
 
 void HValue::SetBlock(HBasicBlock* block) {
-  ASSERT(block_ == NULL || block == NULL);
+  DCHECK(block_ == NULL || block == NULL);
   block_ = block;
   if (id_ == kNoNumber && block != NULL) {
     id_ = block->graph()->GetNextValueID(this);
   }
 }
 
 
 OStream& operator<<(OStream& os, const HValue& v) { return v.PrintTo(os); }
 
 
@@ skipping 57 matching lines @@
       removed->set_tail(new_value->use_list_);
       new_value->use_list_ = removed;
     }
   }
 }
 
 
 void HValue::AddNewRange(Range* r, Zone* zone) {
   if (!HasRange()) ComputeInitialRange(zone);
   if (!HasRange()) range_ = new(zone) Range();
-  ASSERT(HasRange());
+  DCHECK(HasRange());
   r->StackUpon(range_);
   range_ = r;
 }
 
 
 void HValue::RemoveLastAddedRange() {
-  ASSERT(HasRange());
-  ASSERT(range_->next() != NULL);
+  DCHECK(HasRange());
+  DCHECK(range_->next() != NULL);
   range_ = range_->next();
 }
 
 
 void HValue::ComputeInitialRange(Zone* zone) {
-  ASSERT(!HasRange());
+  DCHECK(!HasRange());
   range_ = InferRange(zone);
-  ASSERT(HasRange());
+  DCHECK(HasRange());
 }
 
 
 OStream& operator<<(OStream& os, const HSourcePosition& p) {
   if (p.IsUnknown()) {
     return os << "<?>";
   } else if (FLAG_hydrogen_track_positions) {
     return os << "<" << p.inlining_id() << ":" << p.position() << ">";
   } else {
     return os << "<0:" << p.raw() << ">";
@@ skipping 13 matching lines @@
 OStream& HInstruction::PrintDataTo(OStream& os) const {  // NOLINT
   for (int i = 0; i < OperandCount(); ++i) {
     if (i > 0) os << " ";
     os << NameOf(OperandAt(i));
   }
   return os;
 }
 
 
 void HInstruction::Unlink() {
-  ASSERT(IsLinked());
-  ASSERT(!IsControlInstruction());  // Must never move control instructions.
-  ASSERT(!IsBlockEntry());  // Doesn't make sense to delete these.
-  ASSERT(previous_ != NULL);
+  DCHECK(IsLinked());
+  DCHECK(!IsControlInstruction());  // Must never move control instructions.
+  DCHECK(!IsBlockEntry());  // Doesn't make sense to delete these.
+  DCHECK(previous_ != NULL);
   previous_->next_ = next_;
   if (next_ == NULL) {
-    ASSERT(block()->last() == this);
+    DCHECK(block()->last() == this);
     block()->set_last(previous_);
   } else {
     next_->previous_ = previous_;
   }
   clear_block();
 }
 
 
 void HInstruction::InsertBefore(HInstruction* next) {
-  ASSERT(!IsLinked());
-  ASSERT(!next->IsBlockEntry());
-  ASSERT(!IsControlInstruction());
-  ASSERT(!next->block()->IsStartBlock());
-  ASSERT(next->previous_ != NULL);
+  DCHECK(!IsLinked());
+  DCHECK(!next->IsBlockEntry());
+  DCHECK(!IsControlInstruction());
+  DCHECK(!next->block()->IsStartBlock());
+  DCHECK(next->previous_ != NULL);
   HInstruction* prev = next->previous();
   prev->next_ = this;
   next->previous_ = this;
   next_ = next;
   previous_ = prev;
   SetBlock(next->block());
   if (!has_position() && next->has_position()) {
     set_position(next->position());
   }
 }
 
 
 void HInstruction::InsertAfter(HInstruction* previous) {
-  ASSERT(!IsLinked());
-  ASSERT(!previous->IsControlInstruction());
-  ASSERT(!IsControlInstruction() || previous->next_ == NULL);
+  DCHECK(!IsLinked());
+  DCHECK(!previous->IsControlInstruction());
+  DCHECK(!IsControlInstruction() || previous->next_ == NULL);
   HBasicBlock* block = previous->block();
   // Never insert anything except constants into the start block after finishing
   // it.
   if (block->IsStartBlock() && block->IsFinished() && !IsConstant()) {
-    ASSERT(block->end()->SecondSuccessor() == NULL);
+    DCHECK(block->end()->SecondSuccessor() == NULL);
     InsertAfter(block->end()->FirstSuccessor()->first());
     return;
   }
 
   // If we're inserting after an instruction with side-effects that is
   // followed by a simulate instruction, we need to insert after the
   // simulate instruction instead.
   HInstruction* next = previous->next_;
   if (previous->HasObservableSideEffects() && next != NULL) {
-    ASSERT(next->IsSimulate());
+    DCHECK(next->IsSimulate());
     previous = next;
     next = previous->next_;
   }
 
   previous_ = previous;
   next_ = next;
   SetBlock(block);
   previous->next_ = this;
   if (next != NULL) next->previous_ = this;
   if (block->last() == previous) {
@@ skipping 29 matching lines @@
     if (other_operand == NULL) continue;
     HBasicBlock* other_block = other_operand->block();
     if (cur_block == other_block) {
       if (!other_operand->IsPhi()) {
         HInstruction* cur = this->previous();
         while (cur != NULL) {
           if (cur == other_operand) break;
           cur = cur->previous();
         }
         // Must reach other operand in the same block!
-        ASSERT(cur == other_operand);
+        DCHECK(cur == other_operand);
       }
     } else {
       // If the following assert fires, you may have forgotten an
       // AddInstruction.
-      ASSERT(other_block->Dominates(cur_block));
+      DCHECK(other_block->Dominates(cur_block));
     }
   }
 
   // Verify that instructions that may have side-effects are followed
   // by a simulate instruction.
   if (HasObservableSideEffects() && !IsOsrEntry()) {
-    ASSERT(next()->IsSimulate());
+    DCHECK(next()->IsSimulate());
   }
 
   // Verify that instructions that can be eliminated by GVN have overridden
   // HValue::DataEquals.  The default implementation is UNREACHABLE.  We
   // don't actually care whether DataEquals returns true or false here.
   if (CheckFlag(kUseGVN)) DataEquals(this);
 
   // Verify that all uses are in the graph.
   for (HUseIterator use = uses(); !use.Done(); use.Advance()) {
     if (use.value()->IsInstruction()) {
-      ASSERT(HInstruction::cast(use.value())->IsLinked());
+      DCHECK(HInstruction::cast(use.value())->IsLinked());
     }
   }
 }
 #endif
 
 
 bool HInstruction::CanDeoptimize() {
   // TODO(titzer): make this a virtual method?
   switch (opcode()) {
     case HValue::kAbnormalExit:
@@ skipping 177 matching lines @@
             << argument_count();
 }
 
 
 void HBoundsCheck::ApplyIndexChange() {
   if (skip_check()) return;
 
   DecompositionResult decomposition;
   bool index_is_decomposable = index()->TryDecompose(&decomposition);
   if (index_is_decomposable) {
-    ASSERT(decomposition.base() == base());
+    DCHECK(decomposition.base() == base());
     if (decomposition.offset() == offset() &&
         decomposition.scale() == scale()) return;
   } else {
     return;
   }
 
   ReplaceAllUsesWith(index());
 
   HValue* current_index = decomposition.base();
   int actual_offset = decomposition.offset() + offset();
@@ skipping 40 matching lines @@
       os << "index";
     }
     os << " + " << offset() << ") >> " << scale() << ")";
   }
   if (skip_check()) os << " [DISABLED]";
   return os;
 }
 
 
 void HBoundsCheck::InferRepresentation(HInferRepresentationPhase* h_infer) {
-  ASSERT(CheckFlag(kFlexibleRepresentation));
+  DCHECK(CheckFlag(kFlexibleRepresentation));
   HValue* actual_index = index()->ActualValue();
   HValue* actual_length = length()->ActualValue();
   Representation index_rep = actual_index->representation();
   Representation length_rep = actual_length->representation();
   if (index_rep.IsTagged() && actual_index->type().IsSmi()) {
     index_rep = Representation::Smi();
   }
   if (length_rep.IsTagged() && actual_length->type().IsSmi()) {
     length_rep = Representation::Smi();
   }
@@ skipping 120 matching lines @@
   if (expected_input_types_.Contains(ToBooleanStub::SMI)) {
     return Representation::Smi();
   }
   return Representation::None();
 }
 
 
 bool HBranch::KnownSuccessorBlock(HBasicBlock** block) {
   HValue* value = this->value();
   if (value->EmitAtUses()) {
-    ASSERT(value->IsConstant());
-    ASSERT(!value->representation().IsDouble());
+    DCHECK(value->IsConstant());
+    DCHECK(!value->representation().IsDouble());
     *block = HConstant::cast(value)->BooleanValue()
         ? FirstSuccessor()
         : SecondSuccessor();
     return true;
   }
   *block = NULL;
   return false;
 }
 
 
@@ skipping 113 matching lines @@
   switch (constant->GetInstanceType()) {
     case ODDBALL_TYPE: {
       Unique<Object> unique = constant->GetUnique();
       if (unique.IsKnownGlobal(heap->true_value()) ||
           unique.IsKnownGlobal(heap->false_value())) {
         return heap->boolean_string();
       }
       if (unique.IsKnownGlobal(heap->null_value())) {
         return heap->object_string();
       }
-      ASSERT(unique.IsKnownGlobal(heap->undefined_value()));
+      DCHECK(unique.IsKnownGlobal(heap->undefined_value()));
       return heap->undefined_string();
     }
     case SYMBOL_TYPE:
       return heap->symbol_string();
     case JS_FUNCTION_TYPE:
     case JS_FUNCTION_PROXY_TYPE:
       return heap->function_string();
     default:
       return heap->object_string();
   }
@@ skipping 285 matching lines @@
     if (HConstant::cast(value())->HasInternalizedStringValue()) {
       return value();
     }
   }
   return this;
 }
 
 
 void HCheckInstanceType::GetCheckInterval(InstanceType* first,
                                           InstanceType* last) {
-  ASSERT(is_interval_check());
+  DCHECK(is_interval_check());
   switch (check_) {
     case IS_SPEC_OBJECT:
       *first = FIRST_SPEC_OBJECT_TYPE;
       *last = LAST_SPEC_OBJECT_TYPE;
       return;
     case IS_JS_ARRAY:
       *first = *last = JS_ARRAY_TYPE;
       return;
     default:
       UNREACHABLE();
   }
 }
 
 
 void HCheckInstanceType::GetCheckMaskAndTag(uint8_t* mask, uint8_t* tag) {
-  ASSERT(!is_interval_check());
+  DCHECK(!is_interval_check());
   switch (check_) {
     case IS_STRING:
       *mask = kIsNotStringMask;
       *tag = kStringTag;
       return;
     case IS_INTERNALIZED_STRING:
       *mask = kIsNotStringMask | kIsNotInternalizedMask;
       *tag = kInternalizedTag;
       return;
     default:
@@ skipping 406 matching lines @@
       }
     }
 
     result->base = base;
   }
 }
 
 
 void InductionVariableData::AddCheck(HBoundsCheck* check,
                                      int32_t upper_limit) {
-  ASSERT(limit_validity() != NULL);
+  DCHECK(limit_validity() != NULL);
   if (limit_validity() != check->block() &&
       !limit_validity()->Dominates(check->block())) return;
   if (!phi()->block()->current_loop()->IsNestedInThisLoop(
       check->block()->current_loop())) return;
 
   ChecksRelatedToLength* length_checks = checks();
   while (length_checks != NULL) {
     if (length_checks->length() == check->length()) break;
     length_checks = length_checks->next();
   }
@@ skipping 17 matching lines @@
     }
   }
 }
 
 
 void InductionVariableData::ChecksRelatedToLength::UseNewIndexInCurrentBlock(
     Token::Value token,
     int32_t mask,
     HValue* index_base,
     HValue* context) {
-  ASSERT(first_check_in_block() != NULL);
+  DCHECK(first_check_in_block() != NULL);
   HValue* previous_index = first_check_in_block()->index();
-  ASSERT(context != NULL);
+  DCHECK(context != NULL);
 
   Zone* zone = index_base->block()->graph()->zone();
   set_added_constant(HConstant::New(zone, context, mask));
   if (added_index() != NULL) {
     added_constant()->InsertBefore(added_index());
   } else {
     added_constant()->InsertBefore(first_check_in_block());
   }
 
   if (added_index() == NULL) {
     first_check_in_block()->ReplaceAllUsesWith(first_check_in_block()->index());
     HInstruction* new_index =  HBitwise::New(zone, context, token, index_base,
                                              added_constant());
-    ASSERT(new_index->IsBitwise());
+    DCHECK(new_index->IsBitwise());
     new_index->ClearAllSideEffects();
     new_index->AssumeRepresentation(Representation::Integer32());
     set_added_index(HBitwise::cast(new_index));
     added_index()->InsertBefore(first_check_in_block());
   }
-  ASSERT(added_index()->op() == token);
+  DCHECK(added_index()->op() == token);
 
   added_index()->SetOperandAt(1, index_base);
   added_index()->SetOperandAt(2, added_constant());
   first_check_in_block()->SetOperandAt(0, added_index());
   if (previous_index->HasNoUses()) {
     previous_index->DeleteAndReplaceWith(NULL);
   }
 }
 
 void InductionVariableData::ChecksRelatedToLength::AddCheck(
@@ skipping 89 matching lines @@
 
 
 /*
  * Swaps the information in "update" with the one contained in "this".
  * The swapping is important because this method is used while doing a
  * dominator tree traversal, and "update" will retain the old data that
  * will be restored while backtracking.
  */
 void InductionVariableData::UpdateAdditionalLimit(
     InductionVariableLimitUpdate* update) {
-  ASSERT(update->updated_variable == this);
+  DCHECK(update->updated_variable == this);
   if (update->limit_is_upper) {
     swap(&additional_upper_limit_, &update->limit);
     swap(&additional_upper_limit_is_included_, &update->limit_is_included);
   } else {
     swap(&additional_lower_limit_, &update->limit);
     swap(&additional_lower_limit_is_included_, &update->limit_is_included);
   }
 }
 
 
@@ skipping 110 matching lines @@
 
   Token::Value token = branch->token();
   if (!Token::IsArithmeticCompareOp(token)) return;
 
   HBasicBlock* other_target;
   if (block == branch->SuccessorAt(0)) {
     other_target = branch->SuccessorAt(1);
   } else {
     other_target = branch->SuccessorAt(0);
     token = Token::NegateCompareOp(token);
-    ASSERT(block == branch->SuccessorAt(1));
+    DCHECK(block == branch->SuccessorAt(1));
   }
 
   InductionVariableData* data;
 
   data = GetInductionVariableData(branch->left());
   HValue* limit = branch->right();
   if (data == NULL) {
     data = GetInductionVariableData(branch->right());
     token = Token::ReverseCompareOp(token);
     limit = branch->left();
@@ skipping 44 matching lines @@
 
 
 Range* HMathMinMax::InferRange(Zone* zone) {
   if (representation().IsSmiOrInteger32()) {
     Range* a = left()->range();
     Range* b = right()->range();
     Range* res = a->Copy(zone);
     if (operation_ == kMathMax) {
       res->CombinedMax(b);
     } else {
-      ASSERT(operation_ == kMathMin);
+      DCHECK(operation_ == kMathMin);
       res->CombinedMin(b);
     }
     return res;
   } else {
     return HValue::InferRange(zone);
   }
 }
 
 
 void HPushArguments::AddInput(HValue* value) {
@@ skipping 39 matching lines @@
   int count = OperandCount();
   int position = 0;
   while (position < count && candidate == NULL) {
     HValue* current = OperandAt(position++);
     if (current != this) candidate = current;
   }
   while (position < count) {
     HValue* current = OperandAt(position++);
     if (current != this && current != candidate) return NULL;
   }
-  ASSERT(candidate != this);
+  DCHECK(candidate != this);
   return candidate;
 }
 
 
 void HPhi::DeleteFromGraph() {
-  ASSERT(block() != NULL);
+  DCHECK(block() != NULL);
   block()->RemovePhi(this);
-  ASSERT(block() == NULL);
+  DCHECK(block() == NULL);
 }
 
 
 void HPhi::InitRealUses(int phi_id) {
   // Initialize real uses.
   phi_id_ = phi_id;
   // Compute a conservative approximation of truncating uses before inferring
   // representations. The proper, exact computation will be done later, when
   // inserting representation changes.
   SetFlag(kTruncatingToSmi);
@@ skipping 80 matching lines @@
       os << NameOf(values_[i]);
       if (i > 0) os << ",";
     }
   }
   return os;
 }
 
 
 void HSimulate::ReplayEnvironment(HEnvironment* env) {
   if (done_with_replay_) return;
-  ASSERT(env != NULL);
+  DCHECK(env != NULL);
   env->set_ast_id(ast_id());
   env->Drop(pop_count());
   for (int i = values()->length() - 1; i >= 0; --i) {
     HValue* value = values()->at(i);
     if (HasAssignedIndexAt(i)) {
       env->Bind(GetAssignedIndexAt(i), value);
     } else {
       env->Push(value);
     }
   }
@@ skipping 12 matching lines @@
         ReplayEnvironmentNested(HCapturedObject::cast(value)->values(), other);
       }
     }
   }
 }
 
 
 // Replay captured objects by replacing all captured objects with the
 // same capture id in the current and all outer environments.
 void HCapturedObject::ReplayEnvironment(HEnvironment* env) {
-  ASSERT(env != NULL);
+  DCHECK(env != NULL);
   while (env != NULL) {
     ReplayEnvironmentNested(env->values(), this);
     env = env->outer();
   }
 }
 
 
 OStream& HCapturedObject::PrintDataTo(OStream& os) const {  // NOLINT
   os << "#" << capture_id() << " ";
   return HDematerializedObject::PrintDataTo(os);
 }
 
 
 void HEnterInlined::RegisterReturnTarget(HBasicBlock* return_target,
                                          Zone* zone) {
-  ASSERT(return_target->IsInlineReturnTarget());
+  DCHECK(return_target->IsInlineReturnTarget());
   return_targets_.Add(return_target, zone);
 }
 
 
 OStream& HEnterInlined::PrintDataTo(OStream& os) const {  // NOLINT
   return os << function()->debug_name()->ToCString().get()
             << ", id=" << function()->id().ToInt();
 }
 
 
@@ skipping 55 matching lines @@
     object_map_(object_map),
     has_stable_map_value_(has_stable_map_value),
     has_smi_value_(false),
     has_int32_value_(false),
     has_double_value_(false),
     has_external_reference_value_(false),
     is_not_in_new_space_(is_not_in_new_space),
     boolean_value_(boolean_value),
     is_undetectable_(is_undetectable),
     instance_type_(instance_type) {
-  ASSERT(!object.handle().is_null());
-  ASSERT(!type.IsTaggedNumber() || type.IsNone());
+  DCHECK(!object.handle().is_null());
+  DCHECK(!type.IsTaggedNumber() || type.IsNone());
   Initialize(r);
 }
 
 
 HConstant::HConstant(int32_t integer_value,
                      Representation r,
                      bool is_not_in_new_space,
                      Unique<Object> object)
   : object_(object),
     object_map_(Handle<Map>::null()),
@@ skipping 95 matching lines @@
   if (has_double_value_) {
     if (IsSpecialDouble()) {
       return true;
     }
     return false;
   }
   if (has_external_reference_value_) {
     return false;
   }
 
-  ASSERT(!object_.handle().is_null());
+  DCHECK(!object_.handle().is_null());
   Heap* heap = isolate()->heap();
-  ASSERT(!object_.IsKnownGlobal(heap->minus_zero_value()));
-  ASSERT(!object_.IsKnownGlobal(heap->nan_value()));
+  DCHECK(!object_.IsKnownGlobal(heap->minus_zero_value()));
+  DCHECK(!object_.IsKnownGlobal(heap->nan_value()));
   return
 #define IMMORTAL_IMMOVABLE_ROOT(name) \
       object_.IsKnownGlobal(heap->name()) ||
       IMMORTAL_IMMOVABLE_ROOT_LIST(IMMORTAL_IMMOVABLE_ROOT)
 #undef IMMORTAL_IMMOVABLE_ROOT
 #define INTERNALIZED_STRING(name, value) \
       object_.IsKnownGlobal(heap->name()) ||
       INTERNALIZED_STRING_LIST(INTERNALIZED_STRING)
 #undef INTERNALIZED_STRING
 #define STRING_TYPE(NAME, size, name, Name) \
       object_.IsKnownGlobal(heap->name##_map()) ||
       STRING_TYPE_LIST(STRING_TYPE)
 #undef STRING_TYPE
       false;
 }
 
 
 bool HConstant::EmitAtUses() {
-  ASSERT(IsLinked());
+  DCHECK(IsLinked());
   if (block()->graph()->has_osr() &&
       block()->graph()->IsStandardConstant(this)) {
     // TODO(titzer): this seems like a hack that should be fixed by custom OSR.
     return true;
   }
   if (HasNoUses()) return true;
   if (IsCell()) return false;
   if (representation().IsDouble()) return false;
   if (representation().IsExternal()) return false;
   return true;
 }
 
 
 HConstant* HConstant::CopyToRepresentation(Representation r, Zone* zone) const {
   if (r.IsSmi() && !has_smi_value_) return NULL;
   if (r.IsInteger32() && !has_int32_value_) return NULL;
   if (r.IsDouble() && !has_double_value_) return NULL;
   if (r.IsExternal() && !has_external_reference_value_) return NULL;
   if (has_int32_value_) {
     return new(zone) HConstant(int32_value_, r, is_not_in_new_space_, object_);
   }
   if (has_double_value_) {
     return new(zone) HConstant(double_value_, r, is_not_in_new_space_, object_);
   }
   if (has_external_reference_value_) {
     return new(zone) HConstant(external_reference_value_);
   }
-  ASSERT(!object_.handle().is_null());
+  DCHECK(!object_.handle().is_null());
   return new(zone) HConstant(object_,
                              object_map_,
                              has_stable_map_value_,
                              r,
                              type_,
                              is_not_in_new_space_,
                              boolean_value_,
                              is_undetectable_,
                              instance_type_);
 }
@@ skipping 52 matching lines @@
 
 OStream& HBinaryOperation::PrintDataTo(OStream& os) const {  // NOLINT
   os << NameOf(left()) << " " << NameOf(right());
   if (CheckFlag(kCanOverflow)) os << " !";
   if (CheckFlag(kBailoutOnMinusZero)) os << " -0?";
   return os;
 }
 
 
 void HBinaryOperation::InferRepresentation(HInferRepresentationPhase* h_infer) {
-  ASSERT(CheckFlag(kFlexibleRepresentation));
+  DCHECK(CheckFlag(kFlexibleRepresentation));
   Representation new_rep = RepresentationFromInputs();
   UpdateRepresentation(new_rep, h_infer, "inputs");
 
   if (representation().IsSmi() && HasNonSmiUse()) {
     UpdateRepresentation(
         Representation::Integer32(), h_infer, "use requirements");
   }
 
   if (observed_output_representation_.IsNone()) {
     new_rep = RepresentationFromUses();
@@ skipping 46 matching lines @@
 
 
 void HBinaryOperation::AssumeRepresentation(Representation r) {
   set_observed_input_representation(1, r);
   set_observed_input_representation(2, r);
   HValue::AssumeRepresentation(r);
 }
 
 
 void HMathMinMax::InferRepresentation(HInferRepresentationPhase* h_infer) {
-  ASSERT(CheckFlag(kFlexibleRepresentation));
+  DCHECK(CheckFlag(kFlexibleRepresentation));
   Representation new_rep = RepresentationFromInputs();
   UpdateRepresentation(new_rep, h_infer, "inputs");
   // Do not care about uses.
 }
 
 
 Range* HBitwise::InferRange(Zone* zone) {
   if (op() == Token::BIT_XOR) {
     if (left()->HasRange() && right()->HasRange()) {
       // The maximum value has the high bit, and all bits below, set:
@@ skipping 363 matching lines @@
 OStream& HLoadNamedGeneric::PrintDataTo(OStream& os) const {  // NOLINT
   Handle<String> n = Handle<String>::cast(name());
   return os << NameOf(object()) << "." << n->ToCString().get();
 }
 
 
 OStream& HLoadKeyed::PrintDataTo(OStream& os) const {  // NOLINT
   if (!is_external()) {
     os << NameOf(elements());
   } else {
-    ASSERT(elements_kind() >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
+    DCHECK(elements_kind() >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
            elements_kind() <= LAST_EXTERNAL_ARRAY_ELEMENTS_KIND);
     os << NameOf(elements()) << "." << ElementsKindToString(elements_kind());
   }
 
   os << "[" << NameOf(key());
   if (IsDehoisted()) os << " + " << base_offset();
   os << "]";
 
   if (HasDependency()) os << " " << NameOf(dependency());
   if (RequiresHoleCheck()) os << " check_hole";
@@ skipping 124 matching lines @@
   if (NeedsWriteBarrier()) os << " (write-barrier)";
   if (has_transition()) os << " (transition map " << *transition_map() << ")";
   return os;
 }
 
 
 OStream& HStoreKeyed::PrintDataTo(OStream& os) const {  // NOLINT
   if (!is_external()) {
     os << NameOf(elements());
   } else {
-    ASSERT(elements_kind() >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
+    DCHECK(elements_kind() >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
            elements_kind() <= LAST_EXTERNAL_ARRAY_ELEMENTS_KIND);
     os << NameOf(elements()) << "." << ElementsKindToString(elements_kind());
   }
 
   os << "[" << NameOf(key());
   if (IsDehoisted()) os << " + " << base_offset();
   return os << "] = " << NameOf(value());
 }
 
 
@@ skipping 102 matching lines @@
   Representation input_rep = value()->representation();
   if (!input_rep.IsTagged()) {
     rep = rep.generalize(input_rep);
   }
   return rep;
 }
 
 
 bool HAllocate::HandleSideEffectDominator(GVNFlag side_effect,
                                           HValue* dominator) {
-  ASSERT(side_effect == kNewSpacePromotion);
+  DCHECK(side_effect == kNewSpacePromotion);
   Zone* zone = block()->zone();
   if (!FLAG_use_allocation_folding) return false;
 
   // Try to fold allocations together with their dominating allocations.
   if (!dominator->IsAllocate()) {
     if (FLAG_trace_allocation_folding) {
       PrintF("#%d (%s) cannot fold into #%d (%s)\n",
           id(), Mnemonic(), dominator->id(), dominator->Mnemonic());
     }
     return false;
@@ skipping 32 matching lines @@
       PrintF("#%d (%s) cannot fold into #%d (%s), "
              "can't estimate total allocation size\n",
           id(), Mnemonic(), dominator->id(), dominator->Mnemonic());
     }
     return false;
   }
 
   if (!current_size->IsInteger32Constant()) {
     // If it's not constant then it is a size_in_bytes calculation graph
     // like this: (const_header_size + const_element_size * size).
-    ASSERT(current_size->IsInstruction());
+    DCHECK(current_size->IsInstruction());
 
     HInstruction* current_instr = HInstruction::cast(current_size);
     if (!current_instr->Dominates(dominator_allocate)) {
       if (FLAG_trace_allocation_folding) {
         PrintF("#%d (%s) cannot fold into #%d (%s), dynamic size "
                "value does not dominate target allocation\n",
             id(), Mnemonic(), dominator_allocate->id(),
             dominator_allocate->Mnemonic());
       }
       return false;
     }
   }
 
-  ASSERT((IsNewSpaceAllocation() &&
+  DCHECK((IsNewSpaceAllocation() &&
          dominator_allocate->IsNewSpaceAllocation()) ||
          (IsOldDataSpaceAllocation() &&
          dominator_allocate->IsOldDataSpaceAllocation()) ||
          (IsOldPointerSpaceAllocation() &&
          dominator_allocate->IsOldPointerSpaceAllocation()));
 
   // First update the size of the dominator allocate instruction.
   dominator_size = dominator_allocate->size();
   int32_t original_object_size =
       HConstant::cast(dominator_size)->GetInteger32Constant();
@@ skipping 127 matching lines @@
     // allocation as soon as we have store elimination.
     if (block()->block_id() != dominator_dominator->block()->block_id()) {
       if (FLAG_trace_allocation_folding) {
         PrintF("#%d (%s) cannot fold into #%d (%s), different basic blocks\n",
             id(), Mnemonic(), dominator_dominator->id(),
             dominator_dominator->Mnemonic());
       }
       return NULL;
     }
 
-    ASSERT((IsOldDataSpaceAllocation() &&
+    DCHECK((IsOldDataSpaceAllocation() &&
            dominator_dominator->IsOldDataSpaceAllocation()) ||
            (IsOldPointerSpaceAllocation() &&
            dominator_dominator->IsOldPointerSpaceAllocation()));
 
     int32_t current_size = HConstant::cast(size())->GetInteger32Constant();
     HStoreNamedField* dominator_free_space_size =
         dominator->filler_free_space_size_;
     if (dominator_free_space_size != NULL) {
       // We already hoisted one old space allocation, i.e., we already installed
       // a filler map. Hence, we just have to update the free space size.
       dominator->UpdateFreeSpaceFiller(current_size);
     } else {
       // This is the first old space allocation that gets hoisted. We have to
       // install a filler map since the follwing allocation may cause a GC.
       dominator->CreateFreeSpaceFiller(current_size);
     }
 
     // We can hoist the old space allocation over the actual dominator.
     return dominator_dominator;
   }
   return dominator;
 }
 
 
 void HAllocate::UpdateFreeSpaceFiller(int32_t free_space_size) {
-  ASSERT(filler_free_space_size_ != NULL);
+  DCHECK(filler_free_space_size_ != NULL);
   Zone* zone = block()->zone();
   // We must explicitly force Smi representation here because on x64 we
   // would otherwise automatically choose int32, but the actual store
   // requires a Smi-tagged value.
   HConstant* new_free_space_size = HConstant::CreateAndInsertBefore(
       zone,
       context(),
       filler_free_space_size_->value()->GetInteger32Constant() +
           free_space_size,
       Representation::Smi(),
       filler_free_space_size_);
   filler_free_space_size_->UpdateValue(new_free_space_size);
 }
 
 
 void HAllocate::CreateFreeSpaceFiller(int32_t free_space_size) {
-  ASSERT(filler_free_space_size_ == NULL);
+  DCHECK(filler_free_space_size_ == NULL);
   Zone* zone = block()->zone();
   HInstruction* free_space_instr =
       HInnerAllocatedObject::New(zone, context(), dominating_allocate_,
       dominating_allocate_->size(), type());
   free_space_instr->InsertBefore(this);
   HConstant* filler_map = HConstant::CreateAndInsertAfter(
       zone, Unique<Map>::CreateImmovable(
           isolate()->factory()->free_space_map()), true, free_space_instr);
   HInstruction* store_map = HStoreNamedField::New(zone, context(),
       free_space_instr, HObjectAccess::ForMap(), filler_map);
@@ skipping 457 matching lines @@
                                      HValue* context,
                                      String::Encoding encoding,
                                      HValue* string,
                                      HValue* index) {
   if (FLAG_fold_constants && string->IsConstant() && index->IsConstant()) {
     HConstant* c_string = HConstant::cast(string);
     HConstant* c_index = HConstant::cast(index);
     if (c_string->HasStringValue() && c_index->HasInteger32Value()) {
       Handle<String> s = c_string->StringValue();
       int32_t i = c_index->Integer32Value();
-      ASSERT_LE(0, i);
-      ASSERT_LT(i, s->length());
+      DCHECK_LE(0, i);
+      DCHECK_LT(i, s->length());
       return H_CONSTANT_INT(s->Get(i));
     }
   }
   return new(zone) HSeqStringGetChar(encoding, string, index);
 }
 
 
 #undef H_CONSTANT_INT
 #undef H_CONSTANT_DOUBLE
 
@@ skipping 34 matching lines @@
     HValue* use = it.value();
     if (use->IsBinaryOperation()) {
       HBinaryOperation::cast(use)->set_observed_input_representation(
           it.index(), Representation::Smi());
     }
   }
 }
 
 
 void HPhi::InferRepresentation(HInferRepresentationPhase* h_infer) {
-  ASSERT(CheckFlag(kFlexibleRepresentation));
+  DCHECK(CheckFlag(kFlexibleRepresentation));
   Representation new_rep = RepresentationFromInputs();
   UpdateRepresentation(new_rep, h_infer, "inputs");
   new_rep = RepresentationFromUses();
   UpdateRepresentation(new_rep, h_infer, "uses");
   new_rep = RepresentationFromUseRequirements();
   UpdateRepresentation(new_rep, h_infer, "use requirements");
 }
 
 
 Representation HPhi::RepresentationFromInputs() {
@@ skipping 43 matching lines @@
     }
   }
   return false;
 }
 
 
 // Node-specific verification code is only included in debug mode.
 #ifdef DEBUG
 
 void HPhi::Verify() {
-  ASSERT(OperandCount() == block()->predecessors()->length());
+  DCHECK(OperandCount() == block()->predecessors()->length());
   for (int i = 0; i < OperandCount(); ++i) {
     HValue* value = OperandAt(i);
     HBasicBlock* defining_block = value->block();
     HBasicBlock* predecessor_block = block()->predecessors()->at(i);
-    ASSERT(defining_block == predecessor_block ||
+    DCHECK(defining_block == predecessor_block ||
            defining_block->Dominates(predecessor_block));
   }
 }
 
 
 void HSimulate::Verify() {
   HInstruction::Verify();
-  ASSERT(HasAstId() || next()->IsEnterInlined());
+  DCHECK(HasAstId() || next()->IsEnterInlined());
 }
 
 
 void HCheckHeapObject::Verify() {
   HInstruction::Verify();
-  ASSERT(HasNoUses());
+  DCHECK(HasNoUses());
 }
 
 
 void HCheckValue::Verify() {
   HInstruction::Verify();
-  ASSERT(HasNoUses());
+  DCHECK(HasNoUses());
 }
 
 #endif
 
 
 HObjectAccess HObjectAccess::ForFixedArrayHeader(int offset) {
-  ASSERT(offset >= 0);
-  ASSERT(offset < FixedArray::kHeaderSize);
+  DCHECK(offset >= 0);
+  DCHECK(offset < FixedArray::kHeaderSize);
   if (offset == FixedArray::kLengthOffset) return ForFixedArrayLength();
   return HObjectAccess(kInobject, offset);
 }
 
 
 HObjectAccess HObjectAccess::ForMapAndOffset(Handle<Map> map, int offset,
     Representation representation) {
-  ASSERT(offset >= 0);
+  DCHECK(offset >= 0);
   Portion portion = kInobject;
 
   if (offset == JSObject::kElementsOffset) {
     portion = kElementsPointer;
   } else if (offset == JSObject::kMapOffset) {
     portion = kMaps;
   }
   bool existing_inobject_property = true;
   if (!map.is_null()) {
     existing_inobject_property = (offset <
@@ skipping 19 matching lines @@
     case AllocationSite::kWeakNextOffset:
       return HObjectAccess(kInobject, offset, Representation::Tagged());
     default:
       UNREACHABLE();
   }
   return HObjectAccess(kInobject, offset);
 }
 
 
 HObjectAccess HObjectAccess::ForContextSlot(int index) {
-  ASSERT(index >= 0);
+  DCHECK(index >= 0);
   Portion portion = kInobject;
   int offset = Context::kHeaderSize + index * kPointerSize;
-  ASSERT_EQ(offset, Context::SlotOffset(index) + kHeapObjectTag);
+  DCHECK_EQ(offset, Context::SlotOffset(index) + kHeapObjectTag);
   return HObjectAccess(portion, offset, Representation::Tagged());
 }
 
 
 HObjectAccess HObjectAccess::ForJSArrayOffset(int offset) {
-  ASSERT(offset >= 0);
+  DCHECK(offset >= 0);
   Portion portion = kInobject;
 
   if (offset == JSObject::kElementsOffset) {
     portion = kElementsPointer;
   } else if (offset == JSArray::kLengthOffset) {
     portion = kArrayLengths;
   } else if (offset == JSObject::kMapOffset) {
     portion = kMaps;
   }
   return HObjectAccess(portion, offset);
 }
 
 
 HObjectAccess HObjectAccess::ForBackingStoreOffset(int offset,
     Representation representation) {
-  ASSERT(offset >= 0);
+  DCHECK(offset >= 0);
   return HObjectAccess(kBackingStore, offset, representation,
                        Handle<String>::null(), false, false);
 }
 
 
 HObjectAccess HObjectAccess::ForField(Handle<Map> map,
                                       LookupResult* lookup,
                                       Handle<String> name) {
-  ASSERT(lookup->IsField() || lookup->IsTransitionToField());
+  DCHECK(lookup->IsField() || lookup->IsTransitionToField());
   int index;
   Representation representation;
   if (lookup->IsField()) {
     index = lookup->GetLocalFieldIndexFromMap(*map);
     representation = lookup->representation();
   } else {
     Map* transition = lookup->GetTransitionTarget();
     int descriptor = transition->LastAdded();
     index = transition->instance_descriptors()->GetFieldIndex(descriptor) -
         map->inobject_properties();
@@ skipping 124 matching lines @@
       break;
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 } }  // namespace v8::internal