Consolidated all the key store/load classes in the Hydrogen and Lithium

src/hydrogen-instructions.cc

 // Copyright 2012 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 1604 matching lines @@
           : new(zone) Range();
       result->Shl(c->Integer32Value());
       result->set_can_be_minus_zero(false);
       return result;
     }
   }
   return HValue::InferRange(zone);
 }
 
 
-Range* HLoadKeyedSpecializedArrayElement::InferRange(Zone* zone) {
+Range* HLoadKeyed::InferRange(Zone* zone) {
   switch (elements_kind()) {
     case EXTERNAL_PIXEL_ELEMENTS:
       return new(zone) Range(0, 255);
     case EXTERNAL_BYTE_ELEMENTS:
       return new(zone) Range(-128, 127);
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
       return new(zone) Range(0, 255);
     case EXTERNAL_SHORT_ELEMENTS:
       return new(zone) Range(-32768, 32767);
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
@@ skipping 206 matching lines @@
 }
 
 
 void HLoadNamedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add(".");
   stream->Add(*String::cast(*name())->ToCString());
 }
 
 
-void HLoadKeyedFastElement::PrintDataTo(StringStream* stream) {
-  object()->PrintNameTo(stream);
-  stream->Add("[");
-  key()->PrintNameTo(stream);
-  stream->Add("] ");
-  dependency()->PrintNameTo(stream);
-  if (RequiresHoleCheck()) {
-    stream->Add(" check_hole");
+void HLoadKeyed::PrintDataTo(StringStream* stream) {
+  if (!is_external()) {
+    object()->PrintNameTo(stream);
+    stream->Add("[");

[danno, 2012/10/21 20:44:41]

From the above line

[mvstanton, 2012/10/23 23:44:20]

Done.

+    key()->PrintNameTo(stream);
+    stream->Add("] ");
+    dependency()->PrintNameTo(stream);
+    if (RequiresHoleCheck()) {
+      stream->Add(" check_hole");
+    }

[danno, 2012/10/21 20:44:41]

To here can be shared at the end of the routine. RequiresHoleCheck should always
return false for external arrays, so it will work the way the external array
code expects.

[mvstanton, 2012/10/23 23:44:20]

Done.

+  } else {
+    external_pointer()->PrintNameTo(stream);
+    stream->Add(".");
+    switch (elements_kind()) {

[Sven Panne, 2012/10/22 06:14:18]

DBC: Add a new function ElementsKind2String and use it in PrintElementsKind and
here.

[mvstanton, 2012/10/23 23:44:20]

Good idea, thanks Sven. Now, the string will be different (instead of "byte") it
would be EXTERNAL_BYTE_ELEMENTS, but I guess that is okay with us. I added an
assert to make sure that down this branch we only accept external_*
elementkinds.

+      case EXTERNAL_BYTE_ELEMENTS:
+        stream->Add("byte");
+        break;
+      case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
+        stream->Add("u_byte");
+        break;
+      case EXTERNAL_SHORT_ELEMENTS:
+        stream->Add("short");
+        break;
+      case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
+        stream->Add("u_short");
+        break;
+      case EXTERNAL_INT_ELEMENTS:
+        stream->Add("int");
+        break;
+      case EXTERNAL_UNSIGNED_INT_ELEMENTS:
+        stream->Add("u_int");
+        break;
+      case EXTERNAL_FLOAT_ELEMENTS:
+        stream->Add("float");
+        break;
+      case EXTERNAL_DOUBLE_ELEMENTS:
+        stream->Add("double");
+        break;
+      case EXTERNAL_PIXEL_ELEMENTS:
+        stream->Add("pixel");
+        break;
+      case FAST_ELEMENTS:
+      case FAST_SMI_ELEMENTS:
+      case FAST_DOUBLE_ELEMENTS:
+      case FAST_HOLEY_ELEMENTS:
+      case FAST_HOLEY_SMI_ELEMENTS:
+      case FAST_HOLEY_DOUBLE_ELEMENTS:
+      case DICTIONARY_ELEMENTS:
+      case NON_STRICT_ARGUMENTS_ELEMENTS:
+        UNREACHABLE();
+        break;
+    }
+    stream->Add("[");
+    key()->PrintNameTo(stream);
+    stream->Add("] ");
+    dependency()->PrintNameTo(stream);
   }
 }
 
 
-bool HLoadKeyedFastElement::RequiresHoleCheck() const {
+bool HLoadKeyed::RequiresHoleCheck() const {
   if (IsFastPackedElementsKind(elements_kind())) {
     return false;
   }
 
+  if (IsFastDoubleElementsKind(elements_kind())) {
+    return true;
+  }
+
   for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
     HValue* use = it.value();
-    if (!use->IsChange()) return true;
+    if (!use->IsChange()) {
+      return true;
+    }
   }
 
   return false;
 }
 
 
-void HLoadKeyedFastDoubleElement::PrintDataTo(StringStream* stream) {
-  elements()->PrintNameTo(stream);
-  stream->Add("[");
-  key()->PrintNameTo(stream);
-  stream->Add("] ");
-  dependency()->PrintNameTo(stream);
-}
-
-
 void HLoadKeyedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add("[");
   key()->PrintNameTo(stream);
   stream->Add("]");
 }
 
 
 HValue* HLoadKeyedGeneric::Canonicalize() {
   // Recognize generic keyed loads that use property name generated
   // by for-in statement as a key and rewrite them into fast property load
   // by index.
-  if (key()->IsLoadKeyedFastElement()) {
-    HLoadKeyedFastElement* key_load = HLoadKeyedFastElement::cast(key());
+  if (key()->IsLoadKeyed()) {
+    HLoadKeyed* key_load = HLoadKeyed::cast(key());
+    // TODO(mvstanton): before this didn't recognize the fast double case,
+    // now it does. Is that okay? Do a test that calls Canonicalize on a
+    // fast double HLoadKeyed.

[danno, 2012/10/21 20:44:41]

Yes, this should be OK

[mvstanton, 2012/10/23 23:44:20]

Done.

     if (key_load->object()->IsForInCacheArray()) {
       HForInCacheArray* names_cache =
           HForInCacheArray::cast(key_load->object());
 
       if (names_cache->enumerable() == object()) {
         HForInCacheArray* index_cache =
             names_cache->index_cache();
         HCheckMapValue* map_check =
             new(block()->zone()) HCheckMapValue(object(), names_cache->map());
-        HInstruction* index = new(block()->zone()) HLoadKeyedFastElement(
+        HInstruction* index = new(block()->zone()) HLoadKeyed(
             index_cache,
             key_load->key(),
-            key_load->key());
+            key_load->key(),
+            key_load->elements_kind(),
+            false);
         map_check->InsertBefore(this);
         index->InsertBefore(this);
         HLoadFieldByIndex* load = new(block()->zone()) HLoadFieldByIndex(
             object(), index);
         load->InsertBefore(this);
         return load;
       }
     }
   }
 
   return this;
 }
 
 
-void HLoadKeyedSpecializedArrayElement::PrintDataTo(
-    StringStream* stream) {
-  external_pointer()->PrintNameTo(stream);
-  stream->Add(".");
-  switch (elements_kind()) {
-    case EXTERNAL_BYTE_ELEMENTS:
-      stream->Add("byte");
-      break;
-    case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
-      stream->Add("u_byte");
-      break;
-    case EXTERNAL_SHORT_ELEMENTS:
-      stream->Add("short");
-      break;
-    case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
-      stream->Add("u_short");
-      break;
-    case EXTERNAL_INT_ELEMENTS:
-      stream->Add("int");
-      break;
-    case EXTERNAL_UNSIGNED_INT_ELEMENTS:
-      stream->Add("u_int");
-      break;
-    case EXTERNAL_FLOAT_ELEMENTS:
-      stream->Add("float");
-      break;
-    case EXTERNAL_DOUBLE_ELEMENTS:
-      stream->Add("double");
-      break;
-    case EXTERNAL_PIXEL_ELEMENTS:
-      stream->Add("pixel");
-      break;
-    case FAST_ELEMENTS:
-    case FAST_SMI_ELEMENTS:
-    case FAST_DOUBLE_ELEMENTS:
-    case FAST_HOLEY_ELEMENTS:
-    case FAST_HOLEY_SMI_ELEMENTS:
-    case FAST_HOLEY_DOUBLE_ELEMENTS:
-    case DICTIONARY_ELEMENTS:
-    case NON_STRICT_ARGUMENTS_ELEMENTS:
-      UNREACHABLE();
-      break;
-  }
-  stream->Add("[");
-  key()->PrintNameTo(stream);
-  stream->Add("] ");
-  dependency()->PrintNameTo(stream);
-}
-
-
 void HStoreNamedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add(".");
   ASSERT(name()->IsString());
   stream->Add(*String::cast(*name())->ToCString());
   stream->Add(" = ");
   value()->PrintNameTo(stream);
 }
 
 
 void HStoreNamedField::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add(".");
   stream->Add(*String::cast(*name())->ToCString());
   stream->Add(" = ");
   value()->PrintNameTo(stream);
   stream->Add(" @%d%s", offset(), is_in_object() ? "[in-object]" : "");
   if (NeedsWriteBarrier()) {
     stream->Add(" (write-barrier)");
   }
   if (!transition().is_null()) {
     stream->Add(" (transition map %p)", *transition());
   }
 }
 
 
-void HStoreKeyedFastElement::PrintDataTo(StringStream* stream) {
+void HStoreKeyed::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add("[");
   key()->PrintNameTo(stream);
   stream->Add("] = ");
   value()->PrintNameTo(stream);
+
+
+  if (!is_external()) {
+    object()->PrintNameTo(stream);
+    stream->Add("[");

[danno, 2012/10/21 20:44:41]

Can share from above line...

[mvstanton, 2012/10/23 23:44:20]

Done.

+    key()->PrintNameTo(stream);
+    stream->Add("] = ");
+    value()->PrintNameTo(stream);

[danno, 2012/10/21 20:44:41]

...to line above between both external and non-external cases.

[mvstanton, 2012/10/23 23:44:20]

Done, also fixed duplicate code issue at line 2005.

+  } else {
+    external_pointer()->PrintNameTo(stream);
+    stream->Add(".");
+    switch (elements_kind()) {

[Sven Panne, 2012/10/22 06:14:18]

See my comment above...

[mvstanton, 2012/10/23 23:44:20]

Done.

+      case EXTERNAL_BYTE_ELEMENTS:
+        stream->Add("byte");
+        break;
+      case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
+        stream->Add("u_byte");
+        break;
+      case EXTERNAL_SHORT_ELEMENTS:
+        stream->Add("short");
+        break;
+      case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
+        stream->Add("u_short");
+        break;
+      case EXTERNAL_INT_ELEMENTS:
+        stream->Add("int");
+        break;
+      case EXTERNAL_UNSIGNED_INT_ELEMENTS:
+        stream->Add("u_int");
+        break;
+      case EXTERNAL_FLOAT_ELEMENTS:
+        stream->Add("float");
+        break;
+      case EXTERNAL_DOUBLE_ELEMENTS:
+        stream->Add("double");
+        break;
+      case EXTERNAL_PIXEL_ELEMENTS:
+        stream->Add("pixel");
+        break;
+      case FAST_SMI_ELEMENTS:
+      case FAST_ELEMENTS:
+      case FAST_DOUBLE_ELEMENTS:
+      case FAST_HOLEY_SMI_ELEMENTS:
+      case FAST_HOLEY_ELEMENTS:
+      case FAST_HOLEY_DOUBLE_ELEMENTS:
+      case DICTIONARY_ELEMENTS:
+      case NON_STRICT_ARGUMENTS_ELEMENTS:
+        UNREACHABLE();
+        break;
+    }
+    stream->Add("[");
+    key()->PrintNameTo(stream);
+    stream->Add("] = ");
+    value()->PrintNameTo(stream);
+  }
 }
 
 
-void HStoreKeyedFastDoubleElement::PrintDataTo(StringStream* stream) {
-  elements()->PrintNameTo(stream);
-  stream->Add("[");
-  key()->PrintNameTo(stream);
-  stream->Add("] = ");
-  value()->PrintNameTo(stream);
-}
-
-
 void HStoreKeyedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   stream->Add("[");
   key()->PrintNameTo(stream);
   stream->Add("] = ");
   value()->PrintNameTo(stream);
 }
 
 
-void HStoreKeyedSpecializedArrayElement::PrintDataTo(
-    StringStream* stream) {
-  external_pointer()->PrintNameTo(stream);
-  stream->Add(".");
-  switch (elements_kind()) {
-    case EXTERNAL_BYTE_ELEMENTS:
-      stream->Add("byte");
-      break;
-    case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
-      stream->Add("u_byte");
-      break;
-    case EXTERNAL_SHORT_ELEMENTS:
-      stream->Add("short");
-      break;
-    case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
-      stream->Add("u_short");
-      break;
-    case EXTERNAL_INT_ELEMENTS:
-      stream->Add("int");
-      break;
-    case EXTERNAL_UNSIGNED_INT_ELEMENTS:
-      stream->Add("u_int");
-      break;
-    case EXTERNAL_FLOAT_ELEMENTS:
-      stream->Add("float");
-      break;
-    case EXTERNAL_DOUBLE_ELEMENTS:
-      stream->Add("double");
-      break;
-    case EXTERNAL_PIXEL_ELEMENTS:
-      stream->Add("pixel");
-      break;
-    case FAST_SMI_ELEMENTS:
-    case FAST_ELEMENTS:
-    case FAST_DOUBLE_ELEMENTS:
-    case FAST_HOLEY_SMI_ELEMENTS:
-    case FAST_HOLEY_ELEMENTS:
-    case FAST_HOLEY_DOUBLE_ELEMENTS:
-    case DICTIONARY_ELEMENTS:
-    case NON_STRICT_ARGUMENTS_ELEMENTS:
-      UNREACHABLE();
-      break;
-  }
-  stream->Add("[");
-  key()->PrintNameTo(stream);
-  stream->Add("] = ");
-  value()->PrintNameTo(stream);
-}
-
-
 void HTransitionElementsKind::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
   ElementsKind from_kind = original_map()->elements_kind();
   ElementsKind to_kind = transitioned_map()->elements_kind();
   stream->Add(" %p [%s] -> %p [%s]",
               *original_map(),
               ElementsAccessor::ForKind(from_kind)->name(),
               *transitioned_map(),
               ElementsAccessor::ForKind(to_kind)->name());
 }
@@ skipping 270 matching lines @@
   visited->Add(id());
   // Propagate to the left argument. If the left argument cannot be -0, then
   // the result of the sub operation cannot be either.
   if (range() == NULL || range()->CanBeMinusZero()) {
     return left();
   }
   return NULL;
 }
 
 
-bool HStoreKeyedFastDoubleElement::NeedsCanonicalization() {
+bool HStoreKeyed::NeedsCanonicalization() {
   // If value was loaded from unboxed double backing store or
   // converted from an integer then we don't have to canonicalize it.
-  if (value()->IsLoadKeyedFastDoubleElement() ||
+  if (value()->IsLoadKeyed() ||
       (value()->IsChange() && HChange::cast(value())->from().IsInteger32())) {
     return false;
   }
   return true;
 }
 
 
 #define H_CONSTANT_INT32(val)                                                  \
 new(zone) HConstant(FACTORY->NewNumberFromInt(val, TENURED),                   \
                     Representation::Integer32())
@@ skipping 249 matching lines @@
 
 
 void HCheckPrototypeMaps::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal