Rename ASSERT* to DCHECK*.

src/hydrogen-representation-changes.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-representation-changes.h"
 
 namespace v8 {
 namespace internal {
 
 void HRepresentationChangesPhase::InsertRepresentationChangeForUse(
@@ skipping 23 matching lines @@
       new_value = constant->CopyToRepresentation(to, graph()->zone());
     }
   }
 
   if (new_value == NULL) {
     new_value = new(graph()->zone()) HChange(
         value, to, is_truncating_to_smi, is_truncating_to_int);
     if (!use_value->operand_position(use_index).IsUnknown()) {
       new_value->set_position(use_value->operand_position(use_index));
     } else {
-      ASSERT(!FLAG_hydrogen_track_positions ||
+      DCHECK(!FLAG_hydrogen_track_positions ||
              !graph()->info()->IsOptimizing());
     }
   }
 
   new_value->InsertBefore(next);
   use_value->SetOperandAt(use_index, new_value);
 }
 
 
 static bool IsNonDeoptingIntToSmiChange(HChange* change) {
   Representation from_rep = change->from();
   Representation to_rep = change->to();
   // Flags indicating Uint32 operations are set in a later Hydrogen phase.
-  ASSERT(!change->CheckFlag(HValue::kUint32));
+  DCHECK(!change->CheckFlag(HValue::kUint32));
   return from_rep.IsInteger32() && to_rep.IsSmi() && SmiValuesAre32Bits();
 }
 
 
 void HRepresentationChangesPhase::InsertRepresentationChangesForValue(
     HValue* value) {
   Representation r = value->representation();
   if (r.IsNone()) return;
   if (value->HasNoUses()) {
     if (value->IsForceRepresentation()) value->DeleteAndReplaceWith(NULL);
@@ skipping 17 matching lines @@
         HChange* change = HChange::cast(input);
         if (change->from().Equals(req) && IsNonDeoptingIntToSmiChange(change)) {
           use_value->SetOperandAt(use_index, change->value());
           continue;
         }
       }
     }
     InsertRepresentationChangeForUse(value, use_value, use_index, req);
   }
   if (value->HasNoUses()) {
-    ASSERT(value->IsConstant() || value->IsForceRepresentation());
+    DCHECK(value->IsConstant() || value->IsForceRepresentation());
     value->DeleteAndReplaceWith(NULL);
   } else {
     // The only purpose of a HForceRepresentation is to represent the value
     // after the (possible) HChange instruction.  We make it disappear.
     if (value->IsForceRepresentation()) {
       value->DeleteAndReplaceWith(HForceRepresentation::cast(value)->value());
     }
   }
 }
 
@@ skipping 87 matching lines @@
     // Process normal instructions.
     for (HInstruction* current = block->first(); current != NULL; ) {
       HInstruction* next = current->next();
       InsertRepresentationChangesForValue(current);
       current = next;
     }
   }
 }
 
 } }  // namespace v8::internal