Rename ASSERT* to DCHECK*.

src/hydrogen-check-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-check-elimination.h"
 
 #include "src/hydrogen-alias-analysis.h"
 #include "src/hydrogen-flow-engine.h"
 
 #define GLOBAL 1
@@ skipping 39 matching lines @@
     UNREACHABLE();
     return NULL;
   }
 
   static State StateMerge(State state1, State state2) {
     if (state1 == state2) return state1;
     if ((state1 == CHECKED && state2 == CHECKED_STABLE) ||
         (state2 == CHECKED && state1 == CHECKED_STABLE)) {
       return CHECKED;
     }
-    ASSERT((state1 == CHECKED_STABLE && state2 == UNCHECKED_STABLE) ||
+    DCHECK((state1 == CHECKED_STABLE && state2 == UNCHECKED_STABLE) ||
            (state2 == CHECKED_STABLE && state1 == UNCHECKED_STABLE));
     return UNCHECKED_STABLE;
   }
 
   HValue* object_;  // The object being approximated. NULL => invalid entry.
   HInstruction* check_;  // The last check instruction.
   MapSet maps_;          // The set of known maps for the object.
   State state_;          // The state of this entry.
 };
 
@@ skipping 99 matching lines @@
     }
     return state;
   }
 
  private:
   // Copy state to successor block.
   HCheckTable* Copy(HBasicBlock* succ, HBasicBlock* from_block, Zone* zone) {
     HCheckTable* copy = new(zone) HCheckTable(phase_);
     for (int i = 0; i < size_; i++) {
       HCheckTableEntry* old_entry = &entries_[i];
-      ASSERT(old_entry->maps_->size() > 0);
+      DCHECK(old_entry->maps_->size() > 0);
       HCheckTableEntry* new_entry = &copy->entries_[i];
       new_entry->object_ = old_entry->object_;
       new_entry->maps_ = old_entry->maps_;
       new_entry->state_ = old_entry->state_;
       // Keep the check if the existing check's block dominates the successor.
       if (old_entry->check_ != NULL &&
           old_entry->check_->block()->Dominates(succ)) {
         new_entry->check_ = old_entry->check_;
       } else {
         // Leave it NULL till we meet a new check instruction for this object
@@ skipping 43 matching lines @@
             entry->check_ = cmp;
             entry->state_ = state;
           }
         } else {
           // Learn on the false branch of if(CompareMap(x)).
           if (entry != NULL) {
             EnsureChecked(entry, object, cmp);
             UniqueSet<Map>* maps = entry->maps_->Copy(zone);
             maps->Remove(cmp->map());
             entry->maps_ = maps;
-            ASSERT_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
+            DCHECK_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
           }
         }
         learned = true;
       } else if (is_true_branch && end->IsCompareObjectEqAndBranch()) {
         // Learn on the true branch of if(CmpObjectEq(x, y)).
         HCompareObjectEqAndBranch* cmp =
           HCompareObjectEqAndBranch::cast(end);
         HValue* left = cmp->left()->ActualValue();
         HValue* right = cmp->right()->ActualValue();
         HCheckTableEntry* le = copy->Find(left);
         HCheckTableEntry* re = copy->Find(right);
         if (le == NULL) {
           if (re != NULL) {
             copy->Insert(left, NULL, re->maps_, re->state_);
           }
         } else if (re == NULL) {
           copy->Insert(right, NULL, le->maps_, le->state_);
         } else {
           EnsureChecked(le, cmp->left(), cmp);
           EnsureChecked(re, cmp->right(), cmp);
           le->maps_ = re->maps_ = le->maps_->Intersect(re->maps_, zone);
           le->state_ = re->state_ = HCheckTableEntry::StateMerge(
               le->state_, re->state_);
-          ASSERT_NE(HCheckTableEntry::UNCHECKED_STABLE, le->state_);
-          ASSERT_NE(HCheckTableEntry::UNCHECKED_STABLE, re->state_);
+          DCHECK_NE(HCheckTableEntry::UNCHECKED_STABLE, le->state_);
+          DCHECK_NE(HCheckTableEntry::UNCHECKED_STABLE, re->state_);
         }
         learned = true;
       } else if (end->IsIsStringAndBranch()) {
         HIsStringAndBranch* cmp = HIsStringAndBranch::cast(end);
         HValue* object = cmp->value()->ActualValue();
         HCheckTableEntry* entry = copy->Find(object);
         if (is_true_branch) {
           // Learn on the true branch of if(IsString(x)).
           if (entry == NULL) {
             copy->Insert(object, NULL, string_maps(),
                          HCheckTableEntry::CHECKED);
           } else {
             EnsureChecked(entry, object, cmp);
             entry->maps_ = entry->maps_->Intersect(string_maps(), zone);
-            ASSERT_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
+            DCHECK_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
           }
         } else {
           // Learn on the false branch of if(IsString(x)).
           if (entry != NULL) {
             EnsureChecked(entry, object, cmp);
             entry->maps_ = entry->maps_->Subtract(string_maps(), zone);
-            ASSERT_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
+            DCHECK_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
           }
         }
       }
       // Learning on false branches requires storing negative facts.
     }
 
     if (FLAG_trace_check_elimination) {
       PrintF("B%d checkmaps-table %s from B%d:\n",
              succ->block_id(),
              learned ? "learned" : "copied",
@@ skipping 35 matching lines @@
           this_entry->object_ = NULL;
           compact = true;
         } else {
           this_entry->maps_ =
               this_entry->maps_->Union(that_entry->maps_, zone);
           this_entry->state_ = HCheckTableEntry::StateMerge(
               this_entry->state_, that_entry->state_);
           if (this_entry->check_ != that_entry->check_) {
             this_entry->check_ = NULL;
           }
-          ASSERT(this_entry->maps_->size() > 0);
+          DCHECK(this_entry->maps_->size() > 0);
         }
       }
       if (compact) Compact();
     }
 
     if (FLAG_trace_check_elimination) {
       PrintF("B%d checkmaps-table merged with B%d table:\n",
              succ->block_id(), pred_block->block_id());
       Print(this);
     }
     return this;
   }
 
   void ReduceCheckMaps(HCheckMaps* instr) {
     HValue* object = instr->value()->ActualValue();
     HCheckTableEntry* entry = Find(object);
     if (entry != NULL) {
       // entry found;
       HGraph* graph = instr->block()->graph();
       if (entry->maps_->IsSubset(instr->maps())) {
         // The first check is more strict; the second is redundant.
         if (entry->check_ != NULL) {
-          ASSERT_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
+          DCHECK_NE(HCheckTableEntry::UNCHECKED_STABLE, entry->state_);
           TRACE(("Replacing redundant CheckMaps #%d at B%d with #%d\n",
               instr->id(), instr->block()->block_id(), entry->check_->id()));
           instr->DeleteAndReplaceWith(entry->check_);
           INC_STAT(redundant_);
         } else if (entry->state_ == HCheckTableEntry::UNCHECKED_STABLE) {
-          ASSERT_EQ(NULL, entry->check_);
+          DCHECK_EQ(NULL, entry->check_);
           TRACE(("Marking redundant CheckMaps #%d at B%d as stability check\n",
                  instr->id(), instr->block()->block_id()));
           instr->set_maps(entry->maps_->Copy(graph->zone()));
           instr->MarkAsStabilityCheck();
           entry->state_ = HCheckTableEntry::CHECKED_STABLE;
         } else if (!instr->IsStabilityCheck()) {
           TRACE(("Marking redundant CheckMaps #%d at B%d as dead\n",
               instr->id(), instr->block()->block_id()));
           // Mark check as dead but leave it in the graph as a checkpoint for
           // subsequent checks.
@@ skipping 19 matching lines @@
           entry->state_ = HCheckTableEntry::CHECKED_STABLE;
         }
         if (intersection->size() != instr->maps()->size()) {
           // Narrow set of maps in the second check maps instruction.
           if (entry->check_ != NULL &&
               entry->check_->block() == instr->block() &&
               entry->check_->IsCheckMaps()) {
             // There is a check in the same block so replace it with a more
             // strict check and eliminate the second check entirely.
             HCheckMaps* check = HCheckMaps::cast(entry->check_);
-            ASSERT(!check->IsStabilityCheck());
+            DCHECK(!check->IsStabilityCheck());
             TRACE(("CheckMaps #%d at B%d narrowed\n", check->id(),
                 check->block()->block_id()));
             // Update map set and ensure that the check is alive.
             check->set_maps(intersection);
             check->ClearFlag(HValue::kIsDead);
             TRACE(("Replacing redundant CheckMaps #%d at B%d with #%d\n",
                 instr->id(), instr->block()->block_id(), entry->check_->id()));
             instr->DeleteAndReplaceWith(entry->check_);
           } else {
             TRACE(("CheckMaps #%d at B%d narrowed\n", instr->id(),
@@ skipping 61 matching lines @@
       }
     }
   }
 
   void ReduceLoadNamedField(HLoadNamedField* instr) {
     // Reduce a load of the map field when it is known to be a constant.
     if (!instr->access().IsMap()) {
       // Check if we introduce field maps here.
       MapSet maps = instr->maps();
       if (maps != NULL) {
-        ASSERT_NE(0, maps->size());
+        DCHECK_NE(0, maps->size());
         Insert(instr, NULL, maps, HCheckTableEntry::UNCHECKED_STABLE);
       }
       return;
     }
 
     HValue* object = instr->object()->ActualValue();
     HCheckTableEntry* entry = Find(object);
     if (entry == NULL || entry->maps_->size() != 1) return;  // Not a constant.
 
     EnsureChecked(entry, object, instr);
@@ skipping 150 matching lines @@
   void Kill() {
     size_ = 0;
     cursor_ = 0;
   }
 
   // Kill all unstable entries in the table.
   void KillUnstableEntries() {
     bool compact = false;
     for (int i = 0; i < size_; ++i) {
       HCheckTableEntry* entry = &entries_[i];
-      ASSERT_NOT_NULL(entry->object_);
+      DCHECK_NOT_NULL(entry->object_);
       if (entry->state_ == HCheckTableEntry::CHECKED) {
         entry->object_ = NULL;
         compact = true;
       } else {
         // All checked stable entries become unchecked stable.
         entry->state_ = HCheckTableEntry::UNCHECKED_STABLE;
         entry->check_ = NULL;
       }
     }
     if (compact) Compact();
   }
 
   // Kill everything in the table that may alias {object}.
   void Kill(HValue* object) {
     bool compact = false;
     for (int i = 0; i < size_; i++) {
       HCheckTableEntry* entry = &entries_[i];
-      ASSERT(entry->object_ != NULL);
+      DCHECK(entry->object_ != NULL);
       if (phase_->aliasing_->MayAlias(entry->object_, object)) {
         entry->object_ = NULL;
         compact = true;
       }
     }
     if (compact) Compact();
-    ASSERT(Find(object) == NULL);
+    DCHECK(Find(object) == NULL);
   }
 
   void Compact() {
     // First, compact the array in place.
     int max = size_, dest = 0, old_cursor = cursor_;
     for (int i = 0; i < max; i++) {
       if (entries_[i].object_ != NULL) {
         if (dest != i) entries_[dest] = entries_[i];
         dest++;
       } else {
         if (i < old_cursor) cursor_--;
         size_--;
       }
     }
-    ASSERT(size_ == dest);
-    ASSERT(cursor_ <= size_);
+    DCHECK(size_ == dest);
+    DCHECK(cursor_ <= size_);
 
     // Preserve the age of the entries by moving the older entries to the end.
     if (cursor_ == size_) return;  // Cursor already points at end.
     if (cursor_ != 0) {
       // | L = oldest |   R = newest   |       |
       //              ^ cursor         ^ size  ^ MAX
       HCheckTableEntry tmp_entries[kMaxTrackedObjects];
       int L = cursor_;
       int R = size_ - cursor_;
 
       MemMove(&tmp_entries[0], &entries_[0], L * sizeof(HCheckTableEntry));
       MemMove(&entries_[0], &entries_[L], R * sizeof(HCheckTableEntry));
       MemMove(&entries_[R], &tmp_entries[0], L * sizeof(HCheckTableEntry));
     }
 
     cursor_ = size_;  // Move cursor to end.
   }
 
   static void Print(HCheckTable* table) {
     if (table == NULL) {
       PrintF("  unreachable\n");
       return;
     }
 
     for (int i = 0; i < table->size_; i++) {
       HCheckTableEntry* entry = &table->entries_[i];
-      ASSERT(entry->object_ != NULL);
+      DCHECK(entry->object_ != NULL);
       PrintF("  checkmaps-table @%d: %s #%d ", i,
              entry->object_->IsPhi() ? "phi" : "object", entry->object_->id());
       if (entry->check_ != NULL) {
         PrintF("check #%d ", entry->check_->id());
       }
       MapSet list = entry->maps_;
       PrintF("%d %s maps { ", list->size(),
              HCheckTableEntry::State2String(entry->state_));
       for (int j = 0; j < list->size(); j++) {
         if (j > 0) PrintF(", ");
         PrintF("%" V8PRIxPTR, list->at(j).Hashcode());
       }
       PrintF(" }\n");
     }
   }
 
   HCheckTableEntry* Find(HValue* object) {
     for (int i = size_ - 1; i >= 0; i--) {
       // Search from most-recently-inserted to least-recently-inserted.
       HCheckTableEntry* entry = &entries_[i];
-      ASSERT(entry->object_ != NULL);
+      DCHECK(entry->object_ != NULL);
       if (phase_->aliasing_->MustAlias(entry->object_, object)) return entry;
     }
     return NULL;
   }
 
   void Insert(HValue* object,
               HInstruction* check,
               Unique<Map> map,
               HCheckTableEntry::State state) {
     Insert(object, check, new(zone()) UniqueSet<Map>(map, zone()), state);
   }
 
   void Insert(HValue* object,
               HInstruction* check,
               MapSet maps,
               HCheckTableEntry::State state) {
-    ASSERT(state != HCheckTableEntry::UNCHECKED_STABLE || check == NULL);
+    DCHECK(state != HCheckTableEntry::UNCHECKED_STABLE || check == NULL);
     HCheckTableEntry* entry = &entries_[cursor_++];
     entry->object_ = object;
     entry->check_ = check;
     entry->maps_ = maps;
     entry->state_ = state;
     // If the table becomes full, wrap around and overwrite older entries.
     if (cursor_ == kMaxTrackedObjects) cursor_ = 0;
     if (size_ < kMaxTrackedObjects) size_++;
   }
 
@@ skipping 108 matching lines @@
   PRINT_STAT(removed_cit);
   PRINT_STAT(narrowed);
   PRINT_STAT(loads);
   PRINT_STAT(empty);
   PRINT_STAT(compares_true);
   PRINT_STAT(compares_false);
   PRINT_STAT(transitions);
 }
 
 } }  // namespace v8::internal