Handle misaligned loads and stores in load elimination. Do not track misaligned loads and be conser…

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 194 matching lines @@
       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 instr;
+    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.
       KillFieldInternal(object, FieldOf(JSObject::kMapOffset), NULL);
@@ skipping 17 matching lines @@
   }
 
   // Kill all entries matching the given offset.
   void KillOffset(int offset) {
     int field = FieldOf(offset);
     if (field >= 0 && field < fields_.length()) {
       fields_[field] = NULL;
     }
   }
 
+  // Kill all entries aliasing the given store.
+  void KillStore(HStoreNamedField* s) {
+    int field = FieldOf(s->access());
+    if (field >= 0) {
+      KillFieldInternal(s->object()->ActualValue(), field, s->value());
+    } else {
+      KillIfMisaligned(s);
+    }
+  }
+
+  // Kill multiple entries in the case of a misaligned store.
+  HValue* KillIfMisaligned(HStoreNamedField* instr) {
+    HObjectAccess access = instr->access();
+    if (access.IsInobject()) {
+      int offset = access.offset();
+      if ((offset % kPointerSize) != 0) {
+        // Kill the field containing the first word of the access.
+        HValue* object = instr->object()->ActualValue();
+        int field = offset / kPointerSize;
+        KillFieldInternal(object, field, NULL);
+
+        // Kill the next field in case of overlap.
+        int size = kPointerSize;
+        if (access.representation().IsByte()) size = 1;
+        else if (access.representation().IsInteger32()) size = 4;
+        int next_field = (offset + size - 1) / kPointerSize;
+        if (next_field != field) KillFieldInternal(object, next_field, NULL);
+      }
+    }
+    return instr;
+  }
+
   // Find an entry for the given object and field pair.
   HFieldApproximation* Find(HValue* object, int field) {
     // Search for a field approximation for this object.
     HFieldApproximation* approx = fields_[field];
     while (approx != NULL) {
       if (aliasing_->MustAlias(object, approx->object_)) return approx;
       approx = approx->next_;
     }
     return NULL;
   }
@@ skipping 77 matching lines @@
   }
 
   // Compute the field index for the given object access; -1 if not tracked.
   int FieldOf(HObjectAccess access) {
     return access.IsInobject() ? FieldOf(access.offset()) : -1;
   }
 
   // Compute the field index for the given in-object offset; -1 if not tracked.
   int FieldOf(int offset) {
     if (offset >= kMaxTrackedFields * kPointerSize) return -1;
-    ASSERT((offset % kPointerSize) == 0);  // Assume aligned accesses.
+    // TODO(titzer): track misaligned loads in a separate list?
+    if ((offset % kPointerSize) != 0) return -1;  // Ignore misaligned accesses.
     return offset / kPointerSize;
   }
 
   // Ensure internal storage for the given number of fields.
   void EnsureFields(int num_fields) {
     if (fields_.length() < num_fields) {
       fields_.AddBlock(NULL, num_fields - fields_.length(), zone_);
     }
   }
 
@@ skipping 62 matching lines @@
     }
     if (maps_stored_) {
       table->KillOffset(JSObject::kMapOffset);
     }
     if (elements_stored_) {
       table->KillOffset(JSObject::kElementsOffset);
     }
 
     // Kill non-agreeing fields for each store contained in these effects.
     for (int i = 0; i < stores_.length(); i++) {
-      HStoreNamedField* s = stores_[i];
-      int field = table->FieldOf(s->access());
-      if (field >= 0) {
-        table->KillFieldInternal(s->object()->ActualValue(), field, s->value());
-      }
+      table->KillStore(stores_[i]);
     }
   }
 
   // Union these effects with the other effects.
   void Union(HLoadEliminationEffects* that, Zone* zone) {
     maps_stored_ |= that->maps_stored_;
     fields_stored_ |= that->fields_stored_;
     elements_stored_ |= that->elements_stored_;
     for (int i = 0; i < that->stores_.length(); i++) {
       stores_.Add(that->stores_[i], zone);
@@ skipping 24 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