Flow engine fixes: unreachable block processing, state merging.

src/hydrogen-load-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 114 matching lines @@
       // Improvements possible:
       // - learn from HCheckMaps for field 0
       // - remove unobservable stores (write-after-write)
       // - track cells
       // - track globals
       // - track roots
     }
     return this;
   }
 
-  // Support for global analysis with HFlowEngine: Copy state to sucessor block.
-  HLoadEliminationTable* Copy(HBasicBlock* succ, Zone* zone) {
+  // Support for global analysis with HFlowEngine: 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());
     for (int i = 0; i < fields_.length(); i++) {
       copy->fields_[i] = fields_[i]->Copy(zone);
     }
     if (FLAG_trace_load_elimination) {
       TRACE((" copy-to B%d\n", succ->block_id()));
       copy->Print();
     }
     return copy;
   }
 
   // Support for global analysis with HFlowEngine: Merge this state with
   // the other incoming state.
-  HLoadEliminationTable* Merge(HBasicBlock* succ,
-      HLoadEliminationTable* that, Zone* zone) {
+  void Merge(HBasicBlock* succ, HLoadEliminationTable* that,
+             HBasicBlock* that_block, Zone* zone) {
     if (that->fields_.length() < fields_.length()) {
       // Drop fields not in the other table.
       fields_.Rewind(that->fields_.length());
     }
     for (int i = 0; i < fields_.length(); i++) {
       // Merge the field approximations for like fields.
       HFieldApproximation* approx = fields_[i];
       HFieldApproximation* prev = NULL;
       while (approx != NULL) {
         // TODO(titzer): Merging is O(N * M); sort?
         HFieldApproximation* other = that->Find(approx->object_, i);
         if (other == NULL || !Equal(approx->last_value_, other->last_value_)) {
           // Kill an entry that doesn't agree with the other value.
           if (prev != NULL) {
             prev->next_ = approx->next_;
           } else {
             fields_[i] = approx->next_;
           }
           approx = approx->next_;
           continue;
         }
         prev = approx;
         approx = approx->next_;
       }
     }
-    return this;
   }
 
   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) {
@@ skipping 307 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