Rename ASSERT* to DCHECK*.

src/hydrogen-load-elimination.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/hydrogen-alias-analysis.h"
 #include "src/hydrogen-flow-engine.h"
 #include "src/hydrogen-instructions.h"
 #include "src/hydrogen-load-elimination.h"
 
 namespace v8 {
@@ skipping 104 matching lines @@
     return this;
   }
 
   // Support for global analysis with HFlowEngine: Merge given state with
   // the other incoming state.
   static HLoadEliminationTable* Merge(HLoadEliminationTable* succ_state,
                                       HBasicBlock* succ_block,
                                       HLoadEliminationTable* pred_state,
                                       HBasicBlock* pred_block,
                                       Zone* zone) {
-    ASSERT(pred_state != NULL);
+    DCHECK(pred_state != NULL);
     if (succ_state == NULL) {
       return pred_state->Copy(succ_block, pred_block, zone);
     } else {
       return succ_state->Merge(succ_block, pred_state, pred_block, zone);
     }
   }
 
   // Support for global analysis with HFlowEngine: Given state merged with all
   // the other incoming states, prepare it for use.
   static HLoadEliminationTable* Finish(HLoadEliminationTable* state,
                                        HBasicBlock* block,
                                        Zone* zone) {
-    ASSERT(state != NULL);
+    DCHECK(state != NULL);
     return state;
   }
 
  private:
   // Copy state to successor block.
   HLoadEliminationTable* Copy(HBasicBlock* succ, HBasicBlock* from_block,
                               Zone* zone) {
     HLoadEliminationTable* copy =
         new(zone) HLoadEliminationTable(zone, aliasing_);
     copy->EnsureFields(fields_.length());
@@ skipping 44 matching lines @@
 
   friend class HLoadEliminationEffects;  // Calls Kill() and others.
   friend class HLoadEliminationPhase;
 
  private:
   // Process a load instruction, updating internal table state. If a previous
   // load or store for this object and field exists, return the new value with
   // which the load should be replaced. Otherwise, return {instr}.
   HValue* load(HLoadNamedField* instr) {
     // There must be no loads from non observable in-object properties.
-    ASSERT(!instr->access().IsInobject() ||
+    DCHECK(!instr->access().IsInobject() ||
            instr->access().existing_inobject_property());
 
     int field = FieldOf(instr->access());
     if (field < 0) return instr;
 
     HValue* object = instr->object()->ActualValue();
     HFieldApproximation* approx = FindOrCreate(object, field);
 
     if (approx->last_value_ == NULL) {
       // Load is not redundant. Fill out a new entry.
@@ skipping 161 matching lines @@
       return a->Equals(b);
     }
     return false;
   }
 
   // Remove the last approximation for a field so that it can be reused.
   // We reuse the last entry because it was the first inserted and is thus
   // farthest away from the current instruction.
   HFieldApproximation* ReuseLastApproximation(int field) {
     HFieldApproximation* approx = fields_[field];
-    ASSERT(approx != NULL);
+    DCHECK(approx != NULL);
 
     HFieldApproximation* prev = NULL;
     while (approx->next_ != NULL) {
       prev = approx;
       approx = approx->next_;
     }
     if (prev != NULL) prev->next_ = NULL;
     return approx;
   }
 
@@ skipping 106 matching lines @@
   } else {
     // Perform only local analysis.
     for (int i = 0; i < graph()->blocks()->length(); i++) {
       table->Kill();
       engine.AnalyzeOneBlock(graph()->blocks()->at(i), table);
     }
   }
 }
 
 } }  // namespace v8::internal