Check elimination did not mark some dead blocks.

src/hydrogen-check-elimination.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 119 matching lines @@
       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 HCheckTable* Finish(HCheckTable* state, HBasicBlock* block,
                              Zone* zone) {
     if (state == NULL) {
       block->MarkUnreachable();
+    } else if (block->IsUnreachable()) {
+      state = NULL;
+    }
+    if (FLAG_trace_check_elimination) {
+      PrintF("Processing B%d, checkmaps-table:\n", block->block_id());
+      Print(state);
     }
     return state;
   }
 
  private:
   // Copy state to successor block.
   HCheckTable* Copy(HBasicBlock* succ, HBasicBlock* from_block, Zone* zone) {
     HCheckTable* copy = new(phase_->zone()) HCheckTable(phase_);
     for (int i = 0; i < size_; i++) {
       HCheckTableEntry* old_entry = &entries_[i];
+      ASSERT(old_entry->maps_->size() > 0);
       HCheckTableEntry* new_entry = &copy->entries_[i];
       new_entry->object_ = old_entry->object_;
       new_entry->maps_ = old_entry->maps_->Copy(phase_->zone());
       // 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
         // in the control flow.
@@ skipping 69 matching lines @@
         learned = true;
       }
       // 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",
              from_block->block_id());
-      copy->Print();
+      Print(copy);
     }
 
     return copy;
   }
 
   // Merge this state with the other incoming state.
   HCheckTable* Merge(HBasicBlock* succ, HCheckTable* that,
                      HBasicBlock* pred_block, Zone* zone) {
     if (that->size_ == 0) {
       // If the other state is empty, simply reset.
@@ skipping 26 matching lines @@
           }
           ASSERT(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();
+      Print(this);
     }
     return this;
   }
 
   void ReduceCheckMaps(HCheckMaps* instr) {
     HValue* object = instr->value()->ActualValue();
     HCheckTableEntry* entry = Find(object);
     if (entry != NULL) {
       // entry found;
       MapSet a = entry->maps_;
@@ skipping 42 matching lines @@
                 instr->id(), instr->block()->block_id(), entry->check_->id()));
             instr->DeleteAndReplaceWith(entry->check_);
           } else {
             TRACE(("CheckMaps #%d at B%d narrowed\n", instr->id(),
                 instr->block()->block_id()));
             instr->set_map_set(intersection, graph->zone());
             entry->check_ = instr;
           }
 
           if (FLAG_trace_check_elimination) {
-            Print();
+            Print(this);
           }
           INC_STAT(narrowed_);
         }
       }
     } else {
       // No entry; insert a new one.
       Insert(object, instr, instr->map_set().Copy(phase_->zone()));
     }
   }
 
@@ skipping 173 matching lines @@
       int R = size_ - cursor_;
 
       OS::MemMove(&tmp_entries[0], &entries_[0], L * sizeof(HCheckTableEntry));
       OS::MemMove(&entries_[0], &entries_[L], R * sizeof(HCheckTableEntry));
       OS::MemMove(&entries_[R], &tmp_entries[0], L * sizeof(HCheckTableEntry));
     }
 
     cursor_ = size_;  // Move cursor to end.
   }
 
-  void Print() {
-    for (int i = 0; i < size_; i++) {
-      HCheckTableEntry* entry = &entries_[i];
+  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);
       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 maps { ", list->size());
       for (int j = 0; j < list->size(); j++) {
         if (j > 0) PrintF(", ");
@@ skipping 147 matching lines @@
   PRINT_STAT(removed_cho);
   PRINT_STAT(narrowed);
   PRINT_STAT(loads);
   PRINT_STAT(empty);
   PRINT_STAT(compares_true);
   PRINT_STAT(compares_false);
   PRINT_STAT(transitions);
 }
 
 } }  // namespace v8::internal