Fix dictionary element load to pass correct elements kind.

src/hydrogen.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 1433 matching lines @@
   int32_t entry_size = SeededNumberDictionary::kEntrySize;
   raw_index = AddUncasted<HMul>(raw_index, Add<HConstant>(entry_size));
   raw_index->ClearFlag(HValue::kCanOverflow);
 
   int32_t base_offset = SeededNumberDictionary::kElementsStartIndex;
   HValue* key_index = AddUncasted<HAdd>(raw_index, Add<HConstant>(base_offset));
   key_index->ClearFlag(HValue::kCanOverflow);
 
   HValue* candidate_key = Add<HLoadKeyed>(elements, key_index,
                                           static_cast<HValue*>(NULL),
-                                          FAST_SMI_ELEMENTS);
+                                          FAST_ELEMENTS);
 
   IfBuilder key_compare(this);
   key_compare.IfNot<HCompareObjectEqAndBranch>(key, candidate_key);
   key_compare.Then();
   {
     // Key at the current probe doesn't match, try at the next probe.
     HValue* result = BuildUncheckedDictionaryElementLoadHelper(
         elements, key, hash, mask, current_probe + 1);
     if (result == NULL) {
       key_compare.Deopt("probes exhausted in keyed load dictionary lookup");
       result = graph()->GetConstantUndefined();
     } else {
       Push(result);
     }
   }
   key_compare.Else();
   {
     // Key at current probe matches. Details must be zero, otherwise the
     // dictionary element requires special handling.
     HValue* details_index = AddUncasted<HAdd>(
         raw_index, Add<HConstant>(base_offset + 2));
     details_index->ClearFlag(HValue::kCanOverflow);
 
     HValue* details = Add<HLoadKeyed>(elements, details_index,
                                       static_cast<HValue*>(NULL),
-                                      FAST_SMI_ELEMENTS);
+                                      FAST_ELEMENTS);
     IfBuilder details_compare(this);
     details_compare.If<HCompareNumericAndBranch>(details,
                                                  graph()->GetConstant0(),
                                                  Token::NE);
     details_compare.ThenDeopt("keyed load dictionary element not fast case");
 
     details_compare.Else();
     {
       // Key matches and details are zero --> fast case. Load and return the
       // value.
@@ skipping 49 matching lines @@
 HValue* HGraphBuilder::BuildUncheckedDictionaryElementLoad(HValue* receiver,
                                                            HValue* key) {
   HValue* elements = AddLoadElements(receiver);
 
   HValue* hash = BuildElementIndexHash(key);
 
   HValue* capacity = Add<HLoadKeyed>(
       elements,
       Add<HConstant>(NameDictionary::kCapacityIndex),
       static_cast<HValue*>(NULL),
-      FAST_SMI_ELEMENTS);
+      FAST_ELEMENTS);
 
   HValue* mask = AddUncasted<HSub>(capacity, graph()->GetConstant1());
   mask->ChangeRepresentation(Representation::Integer32());
   mask->ClearFlag(HValue::kCanOverflow);
 
   return BuildUncheckedDictionaryElementLoadHelper(elements, key,
                                                    hash, mask, 0);
 }
 
 
@@ skipping 9721 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal