Add support for dictionary elements to polymorphic crankshaft code.

src/hydrogen.cc

 // Copyright 2011 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 3899 matching lines @@
   }
 
   for (int i = 0; i < maps->length(); ++i) {
     ASSERT(maps->at(i)->IsMap());
     type_todo[maps->at(i)->elements_kind()] = true;
     if (maps->at(i)->elements_kind()
         >= JSObject::FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND) {
       todo_external_array = true;
     }
   }
-  // We can't treat dictionary elements here (need to deopt instead).
-  type_todo[JSObject::DICTIONARY_ELEMENTS] = false;
   // Support for FAST_DOUBLE_ELEMENTS isn't implemented yet, so we deopt.
   type_todo[JSObject::FAST_DOUBLE_ELEMENTS] = false;
 
   HBasicBlock* join = graph()->CreateBasicBlock();
 
   HInstruction* elements_kind_instr =
       AddInstruction(new(zone()) HElementsKind(object));
   HInstruction* elements = NULL;
   HLoadExternalArrayPointer* external_elements = NULL;
   HInstruction* checked_key = NULL;
 
   // FAST_ELEMENTS is assumed to be the first case.
   STATIC_ASSERT(JSObject::FAST_ELEMENTS == 0);
 
   for (JSObject::ElementsKind elements_kind = JSObject::FAST_ELEMENTS;
        elements_kind <= JSObject::LAST_ELEMENTS_KIND;
        elements_kind = JSObject::ElementsKind(elements_kind + 1)) {
-    // After having handled FAST_ELEMENTS in the first run of the loop, we
+    // After having handled FAST_ELEMENTS and DICTIONARY_ELEMENTS, we
     // need to add some code that's executed for all other cases.
-    if (elements_kind == 1 && todo_external_array) {
+    if (elements_kind == JSObject::DICTIONARY_ELEMENTS + 1

[danno, 2011/06/29 14:16:35]

How about a static assert that verifies that DICTIONARY_ELEMENTS + 1 will
actually get visited in this look, like
STATIC_CHECK(JSObject::DICTIONARY_ELEMENTS + 1 <= JSObject::LAST_ELEMENTS_KIND)

Actually, even better, why not compare against
FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND and STATIC_CHECK(JSObject::LAST_ELEMENTS_KIND
== JSObject::LAST_EXTERNAL_ARRAY_ELEMENTS_KIND)? It think that's actually what
you want.

+        && todo_external_array) {
       elements = AddInstruction(new(zone()) HLoadElements(object));
       // We need to forcibly prevent some ElementsKind-dependent instructions
       // from being hoisted out of any loops they might occur in, because
       // the current loop-invariant-code-motion algorithm isn't clever enough
       // to deal with them properly.
       // There's some performance to be gained by developing a smarter
       // solution for this.
       elements->ClearFlag(HValue::kUseGVN);
       HInstruction* length =
           AddInstruction(new(zone()) HExternalArrayLength(elements));
@@ skipping 48 matching lines @@
         elements->ClearFlag(HValue::kUseGVN);
         length = AddInstruction(new(zone()) HFixedArrayLength(elements));
         checked_key = AddInstruction(new(zone()) HBoundsCheck(key, length));
         if (is_store) {
           access = AddInstruction(
               new(zone()) HStoreKeyedFastElement(elements, checked_key, val));
         } else {
           access = AddInstruction(
               new(zone()) HLoadKeyedFastElement(elements, checked_key));
         }
+      } else if (elements_kind == JSObject::DICTIONARY_ELEMENTS) {
+        if (is_store) {
+          access = BuildStoreKeyedGeneric(object, key, val);
+        } else {
+          access = BuildLoadKeyedGeneric(object, key);
+        }
       } else {  // External array elements.
         access = AddInstruction(BuildExternalArrayElementAccess(
             external_elements, checked_key, val, elements_kind, is_store));
       }
       *has_side_effects |= access->HasSideEffects();
       access->set_position(position);
       if (!is_store) {
         Push(access);
       }
       current_block()->Goto(join);
@@ skipping 2565 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal