Flow engine fixes: unreachable block processing, state merging.

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 99 matching lines @@
       }
       // Improvements possible:
       // - eliminate redundant HCheckSmi, HCheckInstanceType instructions
       // - track which values have been HCheckHeapObject'd
     }
 
     return this;
   }
 
   // Global analysis: Copy state to successor block.
-  HCheckTable* Copy(HBasicBlock* succ, Zone* zone) {
+  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];
       HCheckTableEntry* new_entry = &copy->entries_[i];
       // TODO(titzer): keep the check if this block dominates the successor?
       new_entry->object_ = old_entry->object_;
       new_entry->check_ = NULL;
       new_entry->maps_ = old_entry->maps_->Copy(phase_->zone());
     }
     copy->cursor_ = cursor_;
@@ skipping 35 matching lines @@
           re->maps_ = intersect->Copy(zone);
         }
       }
       // Learning on false branches requires storing negative facts.
     }
 
     return copy;
   }
 
   // Global analysis: Merge this state with the other incoming state.
-  HCheckTable* Merge(HBasicBlock* succ, HCheckTable* that, Zone* zone) {
+  void Merge(HBasicBlock* succ, HCheckTable* that,

[titzer, 2014/01/27 12:42:32]

Please keep the interface that it returns the "new" state. The idea being that
some implementations of state might be immutable (e.g. we planned on using this
for escape analysis as well).

[Igor Sheludko, 2014/01/28 16:55:42]

Done.

+             HBasicBlock* that_block, Zone* zone) {
     if (that->size_ == 0) {
       // If the other state is empty, simply reset.
       size_ = 0;
       cursor_ = 0;
-      return this;
+      return;
     }
     bool compact = false;
     for (int i = 0; i < size_; i++) {
       HCheckTableEntry* this_entry = &entries_[i];
       HCheckTableEntry* that_entry = that->Find(this_entry->object_);
       if (that_entry == NULL) {
         this_entry->object_ = NULL;
         compact = true;
       } else {
         this_entry->maps_ = this_entry->maps_->Union(
             that_entry->maps_, phase_->zone());
         if (this_entry->check_ != that_entry->check_) this_entry->check_ = NULL;
         ASSERT(this_entry->maps_->size() > 0);
       }
     }
     if (compact) Compact();
-    return this;
   }
 
   void ReduceCheckMaps(HCheckMaps* instr) {
     HValue* object = instr->value()->ActualValue();
     HCheckTableEntry* entry = Find(object);
     if (entry != NULL) {
       // entry found;
       MapSet a = entry->maps_;
       MapSet i = instr->map_set().Copy(phase_->zone());
       if (a->IsSubset(i)) {
@@ skipping 343 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