Rename ASSERT* to DCHECK*.

src/compiler/scheduler.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.
 
 #include "src/compiler/scheduler.h"
 
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 149 matching lines @@
                           NodeVector(NodeVector::allocator_type(zone)));
   schedule_->immediate_dominator_.resize(schedule_->BasicBlockCount(), NULL);
 }
 
 
 void Scheduler::AddPredecessorsForLoopsAndMerges() {
   for (NodeVectorIter i = loops_and_merges_.begin();
        i != loops_and_merges_.end(); ++i) {
     Node* merge_or_loop = *i;
     BasicBlock* block = schedule_->block(merge_or_loop);
-    ASSERT(block != NULL);
+    DCHECK(block != NULL);
     // For all of the merge's control inputs, add a goto at the end to the
     // merge's basic block.
     for (InputIter j = (*i)->inputs().begin(); j != (*i)->inputs().end(); ++j) {
       if (NodeProperties::IsBasicBlockBegin(*i)) {
         BasicBlock* predecessor_block = schedule_->block(*j);
         if ((*j)->opcode() != IrOpcode::kReturn &&
             (*j)->opcode() != IrOpcode::kDeoptimize) {
-          ASSERT(predecessor_block != NULL);
+          DCHECK(predecessor_block != NULL);
           if (FLAG_trace_turbo_scheduler) {
             IrOpcode::Value opcode = (*i)->opcode();
             PrintF("node %d (%s) in block %d -> block %d\n", (*i)->id(),
                    IrOpcode::Mnemonic(opcode), predecessor_block->id(),
                    block->id());
           }
           schedule_->AddGoto(predecessor_block, block);
         }
       }
     }
   }
 }
 
 
 void Scheduler::AddSuccessorsForCalls() {
   for (NodeVectorIter i = calls_.begin(); i != calls_.end(); ++i) {
     Node* call = *i;
-    ASSERT(call->opcode() == IrOpcode::kCall);
-    ASSERT(NodeProperties::CanLazilyDeoptimize(call));
+    DCHECK(call->opcode() == IrOpcode::kCall);
+    DCHECK(NodeProperties::CanLazilyDeoptimize(call));
 
     Node* lazy_deopt_node = NULL;
     Node* cont_node = NULL;
     // Find the continuation and lazy-deopt nodes among the uses.
     for (UseIter use_iter = call->uses().begin();
          use_iter != call->uses().end(); ++use_iter) {
       switch ((*use_iter)->opcode()) {
         case IrOpcode::kContinuation: {
-          ASSERT(cont_node == NULL);
+          DCHECK(cont_node == NULL);
           cont_node = *use_iter;
           break;
         }
         case IrOpcode::kLazyDeoptimization: {
-          ASSERT(lazy_deopt_node == NULL);
+          DCHECK(lazy_deopt_node == NULL);
           lazy_deopt_node = *use_iter;
           break;
         }
         default:
           break;
       }
     }
-    ASSERT(lazy_deopt_node != NULL);
-    ASSERT(cont_node != NULL);
+    DCHECK(lazy_deopt_node != NULL);
+    DCHECK(cont_node != NULL);
     BasicBlock* cont_successor_block = schedule_->block(cont_node);
     BasicBlock* deopt_successor_block = schedule_->block(lazy_deopt_node);
     Node* call_block_node = NodeProperties::GetControlInput(call);
     BasicBlock* call_block = schedule_->block(call_block_node);
     if (FLAG_trace_turbo_scheduler) {
       IrOpcode::Value opcode = call->opcode();
       PrintF("node %d (%s) in block %d -> block %d\n", call->id(),
              IrOpcode::Mnemonic(opcode), call_block->id(),
              cont_successor_block->id());
       PrintF("node %d (%s) in block %d -> block %d\n", call->id(),
              IrOpcode::Mnemonic(opcode), call_block->id(),
              deopt_successor_block->id());
     }
     schedule_->AddCall(call_block, call, cont_successor_block,
                        deopt_successor_block);
   }
 }
 
 
 void Scheduler::AddSuccessorsForDeopts() {
   for (NodeVectorIter i = deopts_.begin(); i != deopts_.end(); ++i) {
     Node* deopt_block_node = NodeProperties::GetControlInput(*i);
     BasicBlock* deopt_block = schedule_->block(deopt_block_node);
-    ASSERT(deopt_block != NULL);
+    DCHECK(deopt_block != NULL);
     if (FLAG_trace_turbo_scheduler) {
       IrOpcode::Value opcode = (*i)->opcode();
       PrintF("node %d (%s) in block %d -> end\n", (*i)->id(),
              IrOpcode::Mnemonic(opcode), deopt_block->id());
     }
     schedule_->AddDeoptimize(deopt_block, *i);
   }
 }
 
 
 void Scheduler::AddSuccessorsForBranches() {
   for (NodeVectorIter i = branches_.begin(); i != branches_.end(); ++i) {
     Node* branch = *i;
-    ASSERT(branch->opcode() == IrOpcode::kBranch);
+    DCHECK(branch->opcode() == IrOpcode::kBranch);
     Node* branch_block_node = NodeProperties::GetControlInput(branch);
     BasicBlock* branch_block = schedule_->block(branch_block_node);
-    ASSERT(branch_block != NULL);
+    DCHECK(branch_block != NULL);
     UseIter use_iter = branch->uses().begin();
     Node* first_successor = *use_iter;
     ++use_iter;
-    ASSERT(use_iter != branch->uses().end());
+    DCHECK(use_iter != branch->uses().end());
     Node* second_successor = *use_iter;
-    ASSERT(++use_iter == branch->uses().end());
+    DCHECK(++use_iter == branch->uses().end());
     Node* true_successor_node = first_successor->opcode() == IrOpcode::kIfTrue
                                     ? first_successor
                                     : second_successor;
     Node* false_successor_node = first_successor->opcode() == IrOpcode::kIfTrue
                                      ? second_successor
                                      : first_successor;
-    ASSERT(true_successor_node->opcode() == IrOpcode::kIfTrue);
-    ASSERT(false_successor_node->opcode() == IrOpcode::kIfFalse);
+    DCHECK(true_successor_node->opcode() == IrOpcode::kIfTrue);
+    DCHECK(false_successor_node->opcode() == IrOpcode::kIfFalse);
     BasicBlock* true_successor_block = schedule_->block(true_successor_node);
     BasicBlock* false_successor_block = schedule_->block(false_successor_node);
-    ASSERT(true_successor_block != NULL);
-    ASSERT(false_successor_block != NULL);
+    DCHECK(true_successor_block != NULL);
+    DCHECK(false_successor_block != NULL);
     if (FLAG_trace_turbo_scheduler) {
       IrOpcode::Value opcode = branch->opcode();
       PrintF("node %d (%s) in block %d -> block %d\n", branch->id(),
              IrOpcode::Mnemonic(opcode), branch_block->id(),
              true_successor_block->id());
       PrintF("node %d (%s) in block %d -> block %d\n", branch->id(),
              IrOpcode::Mnemonic(opcode), branch_block->id(),
              false_successor_block->id());
     }
     schedule_->AddBranch(branch_block, branch, true_successor_block,
                          false_successor_block);
   }
 }
 
 
 void Scheduler::AddSuccessorsForReturns() {
   for (NodeVectorIter i = returns_.begin(); i != returns_.end(); ++i) {
     Node* return_block_node = NodeProperties::GetControlInput(*i);
     BasicBlock* return_block = schedule_->block(return_block_node);
-    ASSERT(return_block != NULL);
+    DCHECK(return_block != NULL);
     if (FLAG_trace_turbo_scheduler) {
       IrOpcode::Value opcode = (*i)->opcode();
       PrintF("node %d (%s) in block %d -> end\n", (*i)->id(),
              IrOpcode::Mnemonic(opcode), return_block->id());
     }
     schedule_->AddReturn(return_block, *i);
   }
 }
 
 
 BasicBlock* Scheduler::GetCommonDominator(BasicBlock* b1, BasicBlock* b2) {
   while (b1 != b2) {
     int b1_rpo = GetRPONumber(b1);
     int b2_rpo = GetRPONumber(b2);
-    ASSERT(b1_rpo != b2_rpo);
+    DCHECK(b1_rpo != b2_rpo);
     if (b1_rpo < b2_rpo) {
       b2 = schedule_->immediate_dominator_[b2->id()];
     } else {
       b1 = schedule_->immediate_dominator_[b1->id()];
     }
   }
   return b1;
 }
 
 
 void Scheduler::GenerateImmediateDominatorTree() {
   // Build the dominator graph.  TODO(danno): consider using Lengauer & Tarjan's
   // if this becomes really slow.
   if (FLAG_trace_turbo_scheduler) {
     PrintF("------------ IMMEDIATE BLOCK DOMINATORS -----------\n");
   }
   for (size_t i = 0; i < schedule_->rpo_order_.size(); i++) {
     BasicBlock* current_rpo = schedule_->rpo_order_[i];
     if (current_rpo != schedule_->entry()) {
       BasicBlock::Predecessors::iterator current_pred =
           current_rpo->predecessors().begin();
       BasicBlock::Predecessors::iterator end =
           current_rpo->predecessors().end();
-      ASSERT(current_pred != end);
+      DCHECK(current_pred != end);
       BasicBlock* dominator = *current_pred;
       ++current_pred;
       // For multiple predecessors, walk up the rpo ordering until a common
       // dominator is found.
       int current_rpo_pos = GetRPONumber(current_rpo);
       while (current_pred != end) {
         // Don't examine backwards edges
         BasicBlock* pred = *current_pred;
         if (GetRPONumber(pred) < current_rpo_pos) {
           dominator = GetCommonDominator(dominator, *current_pred);
@@ skipping 15 matching lines @@
       : has_changed_rpo_constraints_(true),
         scheduler_(scheduler),
         schedule_(scheduler->schedule_) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
     int id = node->id();
     int max_rpo = 0;
     // Fixed nodes already know their schedule early position.
     if (IsFixedNode(node)) {
       BasicBlock* block = schedule_->block(node);
-      ASSERT(block != NULL);
+      DCHECK(block != NULL);
       max_rpo = block->rpo_number_;
       if (scheduler_->schedule_early_rpo_index_[id] != max_rpo) {
         has_changed_rpo_constraints_ = true;
       }
       scheduler_->schedule_early_rpo_index_[id] = max_rpo;
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Node %d pre-scheduled early at rpo limit %d\n", id, max_rpo);
       }
     }
     return GenericGraphVisit::CONTINUE;
   }
 
   GenericGraphVisit::Control Post(Node* node) {
     int id = node->id();
     int max_rpo = 0;
     // Otherwise, the minimum rpo for the node is the max of all of the inputs.
     if (!IsFixedNode(node)) {
-      ASSERT(!NodeProperties::IsBasicBlockBegin(node));
+      DCHECK(!NodeProperties::IsBasicBlockBegin(node));
       for (InputIter i = node->inputs().begin(); i != node->inputs().end();
            ++i) {
         int control_rpo = scheduler_->schedule_early_rpo_index_[(*i)->id()];
         if (control_rpo > max_rpo) {
           max_rpo = control_rpo;
         }
       }
       if (scheduler_->schedule_early_rpo_index_[id] != max_rpo) {
         has_changed_rpo_constraints_ = true;
       }
@@ skipping 52 matching lines @@
         NodeProperties::HasFixedSchedulePosition(node)) {
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Fixed position node %d is unscheduled, scheduling now\n",
                node->id());
       }
       IrOpcode::Value opcode = node->opcode();
       BasicBlock* block =
           opcode == IrOpcode::kParameter
               ? schedule_->entry()
               : schedule_->block(NodeProperties::GetControlInput(node));
-      ASSERT(block != NULL);
+      DCHECK(block != NULL);
       schedule_->AddNode(block, node);
     }
 
     if (NodeProperties::IsScheduleRoot(node)) {
       scheduler_->schedule_root_nodes_.push_back(node);
     }
 
     return GenericGraphVisit::CONTINUE;
   }
 
   void PostEdge(Node* from, int index, Node* to) {
     // If the edge is from an unscheduled node, then tally it in the use count
     // for all of its inputs. The same criterion will be used in ScheduleLate
     // for decrementing use counts.
     if (!schedule_->IsScheduled(from) && NodeProperties::CanBeScheduled(from)) {
-      ASSERT(!NodeProperties::HasFixedSchedulePosition(from));
+      DCHECK(!NodeProperties::HasFixedSchedulePosition(from));
       ++scheduler_->unscheduled_uses_[to->id()];
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Incrementing uses of node %d from %d to %d\n", to->id(),
                from->id(), scheduler_->unscheduled_uses_[to->id()]);
       }
     }
   }
 
  private:
   Scheduler* scheduler_;
@@ skipping 15 matching lines @@
 class ScheduleLateNodeVisitor : public NullNodeVisitor {
  public:
   explicit ScheduleLateNodeVisitor(Scheduler* scheduler)
       : scheduler_(scheduler), schedule_(scheduler_->schedule_) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
     // Don't schedule nodes that cannot be scheduled or are already scheduled.
     if (!NodeProperties::CanBeScheduled(node) || schedule_->IsScheduled(node)) {
       return GenericGraphVisit::CONTINUE;
     }
-    ASSERT(!NodeProperties::HasFixedSchedulePosition(node));
+    DCHECK(!NodeProperties::HasFixedSchedulePosition(node));
 
     // If all the uses of a node have been scheduled, then the node itself can
     // be scheduled.
     bool eligible = scheduler_->unscheduled_uses_[node->id()] == 0;
     if (FLAG_trace_turbo_scheduler) {
       PrintF("Testing for schedule eligibility for node %d -> %s\n", node->id(),
              eligible ? "true" : "false");
     }
     if (!eligible) return GenericGraphVisit::DEFER;
 
     // Determine the dominating block for all of the uses of this node. It is
     // the latest block that this node can be scheduled in.
     BasicBlock* block = NULL;
     for (Node::Uses::iterator i = node->uses().begin(); i != node->uses().end();
          ++i) {
       BasicBlock* use_block = GetBlockForUse(i.edge());
       block = block == NULL ? use_block : use_block == NULL
                                               ? block
                                               : scheduler_->GetCommonDominator(
                                                     block, use_block);
     }
-    ASSERT(block != NULL);
+    DCHECK(block != NULL);
 
     int min_rpo = scheduler_->schedule_early_rpo_index_[node->id()];
     if (FLAG_trace_turbo_scheduler) {
       PrintF(
           "Schedule late conservative for node %d is block %d at "
           "loop depth %d, min rpo = %d\n",
           node->id(), block->id(), block->loop_depth_, min_rpo);
     }
     // Hoist nodes out of loops if possible. Nodes can be hoisted iteratively
     // into enlcosing loop pre-headers until they would preceed their
     // ScheduleEarly position.
     BasicBlock* hoist_block = block;
     while (hoist_block != NULL && hoist_block->rpo_number_ >= min_rpo) {
       if (hoist_block->loop_depth_ < block->loop_depth_) {
         block = hoist_block;
         if (FLAG_trace_turbo_scheduler) {
           PrintF("Hoisting node %d to block %d\n", node->id(), block->id());
         }
       }
       // Try to hoist to the pre-header of the loop header.
       hoist_block = hoist_block->loop_header();
       if (hoist_block != NULL) {
         BasicBlock* pre_header = schedule_->dominator(hoist_block);
-        ASSERT(pre_header == NULL ||
+        DCHECK(pre_header == NULL ||
                *hoist_block->predecessors().begin() == pre_header);
         if (FLAG_trace_turbo_scheduler) {
           PrintF(
               "Try hoist to pre-header block %d of loop header block %d,"
               " depth would be %d\n",
               pre_header->id(), hoist_block->id(), pre_header->loop_depth_);
         }
         hoist_block = pre_header;
       }
     }
 
     ScheduleNode(block, node);
 
     return GenericGraphVisit::CONTINUE;
   }
 
  private:
   BasicBlock* GetBlockForUse(Node::Edge edge) {
     Node* use = edge.from();
     IrOpcode::Value opcode = use->opcode();
     // If the use is a phi, forward through the the phi to the basic block
     // corresponding to the phi's input.
     if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
       int index = edge.index();
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Use %d is input %d to a phi\n", use->id(), index);
       }
       use = NodeProperties::GetControlInput(use, 0);
       opcode = use->opcode();
-      ASSERT(opcode == IrOpcode::kMerge || opcode == IrOpcode::kLoop);
+      DCHECK(opcode == IrOpcode::kMerge || opcode == IrOpcode::kLoop);
       use = NodeProperties::GetControlInput(use, index);
     }
     BasicBlock* result = schedule_->block(use);
     if (result == NULL) return NULL;
     if (FLAG_trace_turbo_scheduler) {
       PrintF("Must dominate use %d in block %d\n", use->id(), result->id());
     }
     return result;
   }
 
   bool IsNodeEligible(Node* node) {
     bool eligible = scheduler_->unscheduled_uses_[node->id()] == 0;
     return eligible;
   }
 
   void ScheduleNode(BasicBlock* block, Node* node) {
     schedule_->PlanNode(block, node);
     scheduler_->scheduled_nodes_[block->id()].push_back(node);
 
     // Reduce the use count of the node's inputs to potentially make them
     // scheduable.
     for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
-      ASSERT(scheduler_->unscheduled_uses_[(*i)->id()] > 0);
+      DCHECK(scheduler_->unscheduled_uses_[(*i)->id()] > 0);
       --scheduler_->unscheduled_uses_[(*i)->id()];
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Decrementing use count for node %d from node %d (now %d)\n",
                (*i)->id(), i.edge().from()->id(),
                scheduler_->unscheduled_uses_[(*i)->id()]);
         if (scheduler_->unscheduled_uses_[(*i)->id()] == 0) {
           PrintF("node %d is now eligible for scheduling\n", (*i)->id());
         }
       }
     }
@@ skipping 163 matching lines @@
     if (block->loop_end_ >= 0) {
       PrintF(" range: [%d, %d)", block->rpo_number_, block->loop_end_);
     }
     PrintF("\n");
   }
 }
 
 
 static void VerifySpecialRPO(int num_loops, LoopInfo* loops,
                              BasicBlockVector* order) {
-  ASSERT(order->size() > 0);
-  ASSERT((*order)[0]->id() == 0);  // entry should be first.
+  DCHECK(order->size() > 0);
+  DCHECK((*order)[0]->id() == 0);  // entry should be first.
 
   for (int i = 0; i < num_loops; i++) {
     LoopInfo* loop = &loops[i];
     BasicBlock* header = loop->header;
 
-    ASSERT(header != NULL);
-    ASSERT(header->rpo_number_ >= 0);
-    ASSERT(header->rpo_number_ < static_cast<int>(order->size()));
-    ASSERT(header->loop_end_ >= 0);
-    ASSERT(header->loop_end_ <= static_cast<int>(order->size()));
-    ASSERT(header->loop_end_ > header->rpo_number_);
+    DCHECK(header != NULL);
+    DCHECK(header->rpo_number_ >= 0);
+    DCHECK(header->rpo_number_ < static_cast<int>(order->size()));
+    DCHECK(header->loop_end_ >= 0);
+    DCHECK(header->loop_end_ <= static_cast<int>(order->size()));
+    DCHECK(header->loop_end_ > header->rpo_number_);
 
     // Verify the start ... end list relationship.
     int links = 0;
     BlockList* l = loop->start;
-    ASSERT(l != NULL && l->block == header);
+    DCHECK(l != NULL && l->block == header);
     bool end_found;
     while (true) {
       if (l == NULL || l == loop->end) {
         end_found = (loop->end == l);
         break;
       }
       // The list should be in same order as the final result.
-      ASSERT(l->block->rpo_number_ == links + loop->header->rpo_number_);
+      DCHECK(l->block->rpo_number_ == links + loop->header->rpo_number_);
       links++;
       l = l->next;
-      ASSERT(links < static_cast<int>(2 * order->size()));  // cycle?
+      DCHECK(links < static_cast<int>(2 * order->size()));  // cycle?
     }
-    ASSERT(links > 0);
-    ASSERT(links == (header->loop_end_ - header->rpo_number_));
-    ASSERT(end_found);
+    DCHECK(links > 0);
+    DCHECK(links == (header->loop_end_ - header->rpo_number_));
+    DCHECK(end_found);
 
     // Check the contiguousness of loops.
     int count = 0;
     for (int j = 0; j < static_cast<int>(order->size()); j++) {
       BasicBlock* block = order->at(j);
-      ASSERT(block->rpo_number_ == j);
+      DCHECK(block->rpo_number_ == j);
       if (j < header->rpo_number_ || j >= header->loop_end_) {
-        ASSERT(!loop->members->Contains(block->id()));
+        DCHECK(!loop->members->Contains(block->id()));
       } else {
         if (block == header) {
-          ASSERT(!loop->members->Contains(block->id()));
+          DCHECK(!loop->members->Contains(block->id()));
         } else {
-          ASSERT(loop->members->Contains(block->id()));
+          DCHECK(loop->members->Contains(block->id()));
         }
         count++;
       }
     }
-    ASSERT(links == count);
+    DCHECK(links == count);
   }
 }
 #endif  // DEBUG
 
 
 // Compute the special reverse-post-order block ordering, which is essentially
 // a RPO of the graph where loop bodies are contiguous. Properties:
 // 1. If block A is a predecessor of B, then A appears before B in the order,
 //    unless B is a loop header and A is in the loop headed at B
 //    (i.e. A -> B is a backedge).
@@ skipping 32 matching lines @@
       if (succ->rpo_number_ == kBlockOnStack) {
         // The successor is on the stack, so this is a backedge (cycle).
         backedges.Add(
             std::pair<BasicBlock*, int>(frame->block, frame->index - 1), zone_);
         if (succ->loop_end_ < 0) {
           // Assign a new loop number to the header if it doesn't have one.
           succ->loop_end_ = num_loops++;
         }
       } else {
         // Push the successor onto the stack.
-        ASSERT(succ->rpo_number_ == kBlockUnvisited1);
+        DCHECK(succ->rpo_number_ == kBlockUnvisited1);
         stack_depth = Push(stack, stack_depth, succ, kBlockUnvisited1);
       }
     } else {
       // Finished with all successors; pop the stack and add the block.
       order = order->Add(zone_, frame->block);
       frame->block->rpo_number_ = kBlockVisited1;
       stack_depth--;
     }
   }
 
@@ skipping 20 matching lines @@
       BasicBlock* succ = NULL;
 
       if (frame->index < block->SuccessorCount()) {
         // Process the next normal successor.
         succ = block->SuccessorAt(frame->index++);
       } else if (block->IsLoopHeader()) {
         // Process additional outgoing edges from the loop header.
         if (block->rpo_number_ == kBlockOnStack) {
           // Finish the loop body the first time the header is left on the
           // stack.
-          ASSERT(loop != NULL && loop->header == block);
+          DCHECK(loop != NULL && loop->header == block);
           loop->start = order->Add(zone_, block);
           order = loop->end;
           block->rpo_number_ = kBlockVisited2;
           // Pop the loop stack and continue visiting outgoing edges within the
           // the context of the outer loop, if any.
           loop = loop->prev;
           // We leave the loop header on the stack; the rest of this iteration
           // and later iterations will go through its outgoing edges list.
         }
 
         // Use the next outgoing edge if there are any.
         int outgoing_index = frame->index - block->SuccessorCount();
         LoopInfo* info = &loops[block->loop_end_];
-        ASSERT(loop != info);
+        DCHECK(loop != info);
         if (info->outgoing != NULL &&
             outgoing_index < info->outgoing->length()) {
           succ = info->outgoing->at(outgoing_index);
           frame->index++;
         }
       }
 
       if (succ != NULL) {
         // Process the next successor.
         if (succ->rpo_number_ == kBlockOnStack) continue;
         if (succ->rpo_number_ == kBlockVisited2) continue;
-        ASSERT(succ->rpo_number_ == kBlockUnvisited2);
+        DCHECK(succ->rpo_number_ == kBlockUnvisited2);
         if (loop != NULL && !loop->members->Contains(succ->id())) {
           // The successor is not in the current loop or any nested loop.
           // Add it to the outgoing edges of this loop and visit it later.
           loop->AddOutgoing(zone_, succ);
         } else {
           // Push the successor onto the stack.
           stack_depth = Push(stack, stack_depth, succ, kBlockUnvisited2);
           if (succ->IsLoopHeader()) {
             // Push the inner loop onto the loop stack.
-            ASSERT(succ->loop_end_ >= 0 && succ->loop_end_ < num_loops);
+            DCHECK(succ->loop_end_ >= 0 && succ->loop_end_ < num_loops);
             LoopInfo* next = &loops[succ->loop_end_];
             next->end = order;
             next->prev = loop;
             loop = next;
           }
         }
       } else {
         // Finished with all successors of the current block.
         if (block->IsLoopHeader()) {
           // If we are going to pop a loop header, then add its entire body.
@@ skipping 36 matching lines @@
       current->loop_end_ = end == NULL ? static_cast<int>(final_order->size())
                                        : end->block->rpo_number_;
       current_header = current_loop->header;
       if (FLAG_trace_turbo_scheduler) {
         PrintF("Block %d is a loop header, increment loop depth to %d\n",
                current->id(), loop_depth);
       }
     } else {
       while (current_header != NULL &&
              current->rpo_number_ >= current_header->loop_end_) {
-        ASSERT(current_header->IsLoopHeader());
-        ASSERT(current_loop != NULL);
+        DCHECK(current_header->IsLoopHeader());
+        DCHECK(current_loop != NULL);
         current_loop = current_loop->prev;
         current_header = current_loop == NULL ? NULL : current_loop->header;
         --loop_depth;
       }
     }
     current->loop_depth_ = loop_depth;
     if (FLAG_trace_turbo_scheduler) {
       if (current->loop_header_ == NULL) {
         PrintF("Block %d's loop header is NULL, loop depth %d\n", current->id(),
                current->loop_depth_);
       } else {
         PrintF("Block %d's loop header is block %d, loop depth %d\n",
                current->id(), current->loop_header_->id(),
                current->loop_depth_);
       }
     }
   }
 
 #if DEBUG
   if (FLAG_trace_turbo_scheduler) PrintRPO(num_loops, loops, final_order);
   VerifySpecialRPO(num_loops, loops, final_order);
 #endif
   return final_order;
 }
 }
 }
 }  // namespace v8::internal::compiler