Rename ASSERT* to DCHECK*.

src/compiler/generic-node-inl.h

 // 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.
 
 #ifndef V8_COMPILER_GENERIC_NODE_INL_H_
 #define V8_COMPILER_GENERIC_NODE_INL_H_
 
 #include "src/v8.h"
 
 #include "src/compiler/generic-graph.h"
@@ skipping 44 matching lines @@
 GenericNode<B, S>::Uses::end() {
   return typename GenericNode<B, S>::Uses::iterator();
 }
 
 template <class B, class S>
 void GenericNode<B, S>::ReplaceUses(GenericNode* replace_to) {
   for (Use* use = first_use_; use != NULL; use = use->next) {
     use->from->GetInputRecordPtr(use->input_index)->to = replace_to;
   }
   if (replace_to->last_use_ == NULL) {
-    ASSERT_EQ(NULL, replace_to->first_use_);
+    DCHECK_EQ(NULL, replace_to->first_use_);
     replace_to->first_use_ = first_use_;
   } else {
-    ASSERT_NE(NULL, replace_to->first_use_);
+    DCHECK_NE(NULL, replace_to->first_use_);
     replace_to->last_use_->next = first_use_;
     first_use_->prev = replace_to->last_use_;
   }
   replace_to->last_use_ = last_use_;
   replace_to->use_count_ += use_count_;
   use_count_ = 0;
   first_use_ = NULL;
   last_use_ = NULL;
 }
 
@@ skipping 17 matching lines @@
   for (typename Inputs::iterator iter(inputs().begin()); iter != inputs().end();
        ++iter) {
     iter.GetInput()->Update(NULL);
   }
 }
 
 template <class B, class S>
 void GenericNode<B, S>::TrimInputCount(int new_input_count) {
   if (new_input_count == input_count_) return;  // Nothing to do.
 
-  ASSERT(new_input_count < input_count_);
+  DCHECK(new_input_count < input_count_);
 
   // Update inline inputs.
   for (int i = new_input_count; i < input_count_; i++) {
     typename GenericNode<B, S>::Input* input = GetInputRecordPtr(i);
     input->Update(NULL);
   }
   input_count_ = new_input_count;
 }
 
 template <class B, class S>
@@ skipping 43 matching lines @@
   inputs_.appendable_->push_back(new_input);
   new_use->input_index = input_count_;
   new_use->from = this;
   to_append->AppendUse(new_use);
   input_count_++;
 }
 
 template <class B, class S>
 void GenericNode<B, S>::InsertInput(Zone* zone, int index,
                                     GenericNode<B, S>* to_insert) {
-  ASSERT(index >= 0 && index < InputCount());
+  DCHECK(index >= 0 && index < InputCount());
   // TODO(turbofan): Optimize this implementation!
   AppendInput(zone, InputAt(InputCount() - 1));
   for (int i = InputCount() - 1; i > index; --i) {
     ReplaceInput(i, InputAt(i - 1));
   }
   ReplaceInput(index, to_insert);
 }
 
 template <class B, class S>
 void GenericNode<B, S>::AppendUse(Use* use) {
@@ skipping 55 matching lines @@
     ++use;
     ++input;
   }
   return result;
 }
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_GENERIC_NODE_INL_H_