Improve load elimination handling of transitioning stores.

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 25 matching lines @@
 #define GLOBAL true
 #define TRACE(x) if (FLAG_trace_load_elimination) PrintF x
 
 static const int kMaxTrackedFields = 16;
 static const int kMaxTrackedObjects = 5;
 
 // An element in the field approximation list.
 class HFieldApproximation : public ZoneObject {
  public:  // Just a data blob.
   HValue* object_;
-  HLoadNamedField* last_load_;
   HValue* last_value_;
   HFieldApproximation* next_;
 
   // Recursively copy the entire linked list of field approximations.
   HFieldApproximation* Copy(Zone* zone) {
     if (this == NULL) return NULL;
     HFieldApproximation* copy = new(zone) HFieldApproximation();
     copy->object_ = this->object_;
-    copy->last_load_ = this->last_load_;
     copy->last_value_ = this->last_value_;
     copy->next_ = this->next_->Copy(zone);
     return copy;
   }
 };
 
 
 // The main datastructure used during load/store elimination. Each in-object
 // field is tracked separately. For each field, store a list of known field
 // values for known objects.
@@ skipping 124 matching lines @@
   // which the load should be replaced. Otherwise, return {instr}.
   HValue* load(HLoadNamedField* instr) {
     int field = FieldOf(instr->access());
     if (field < 0) return instr;
 
     HValue* object = instr->object()->ActualValue();
     HFieldApproximation* approx = FindOrCreate(object, field);
 
     if (approx->last_value_ == NULL) {
       // Load is not redundant. Fill out a new entry.
-      approx->last_load_ = instr;
       approx->last_value_ = instr;
       return instr;
     } else {
       // Eliminate the load. Reuse previously stored value or load instruction.
       return approx->last_value_;
     }
   }
 
   // Process a store instruction, updating internal table state. If a previous
   // store to the same object and field makes this store redundant (e.g. because
   // the stored values are the same), return NULL indicating that this store
   // instruction is redundant. Otherwise, return {instr}.
   HValue* store(HStoreNamedField* instr) {
     int field = FieldOf(instr->access());
     if (field < 0) return KillIfMisaligned(instr);
 
     HValue* object = instr->object()->ActualValue();
     HValue* value = instr->value();
 
-    // Kill non-equivalent may-alias entries.
-    KillFieldInternal(object, field, value);
     if (instr->has_transition()) {
-      // A transition store alters the map of the object.
-      // TODO(titzer): remember the new map (a constant) for the object.
+      // A transition introduces a new field and alters the map of the object.
+      // Since the field in the object is new, it cannot alias existing entries.
+      // TODO(titzer): introduce a constant for the new map and remember it.
       KillFieldInternal(object, FieldOf(JSObject::kMapOffset), NULL);
+    } else {
+      // Kill non-equivalent may-alias entries.
+      KillFieldInternal(object, field, value);
     }
     HFieldApproximation* approx = FindOrCreate(object, field);
 
     if (Equal(approx->last_value_, value)) {
       // The store is redundant because the field already has this value.
       return NULL;
     } else {
       // The store is not redundant. Update the entry.
-      approx->last_load_ = NULL;
       approx->last_value_ = value;
       return instr;
     }
   }
 
   // Kill everything in this table.
   void Kill() {
     fields_.Rewind(0);
   }
 
@@ skipping 62 matching lines @@
     if (count >= kMaxTrackedObjects) {
       // Pull the last entry off the end and repurpose it for this object.
       approx = ReuseLastApproximation(field);
     } else {
       // Allocate a new entry.
       approx = new(zone_) HFieldApproximation();
     }
 
     // Insert the entry at the head of the list.
     approx->object_ = object;
-    approx->last_load_ = NULL;
     approx->last_value_ = NULL;
     approx->next_ = fields_[field];
     fields_[field] = approx;
 
     return approx;
   }
 
   // Kill all entries for a given field that _may_ alias the given object
   // and do _not_ have the given value.
   void KillFieldInternal(HValue* object, int field, HValue* value) {
@@ skipping 62 matching lines @@
       fields_.AddBlock(NULL, num_fields - fields_.length(), zone_);
     }
   }
 
   // Print this table to stdout.
   void Print() {
     for (int i = 0; i < fields_.length(); i++) {
       PrintF("  field %d: ", i);
       for (HFieldApproximation* a = fields_[i]; a != NULL; a = a->next_) {
         PrintF("[o%d =", a->object_->id());
-        if (a->last_load_ != NULL) PrintF(" L%d", a->last_load_->id());
         if (a->last_value_ != NULL) PrintF(" v%d", a->last_value_->id());
         PrintF("] ");
       }
       PrintF("\n");
     }
   }
 
   Zone* zone_;
   ZoneList<HFieldApproximation*> fields_;
   HAliasAnalyzer* aliasing_;
@@ skipping 90 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