Promote double arrays to FAST_ELEMENT that use generic KeyedLoadIC

src/runtime.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 4252 matching lines @@
         int entry = dictionary->FindEntry(key);
         if ((entry != StringDictionary::kNotFound) &&
             (dictionary->DetailsAt(entry).type() == NORMAL)) {
           Object* value = dictionary->ValueAt(entry);
           if (!receiver->IsGlobalObject()) return value;
           value = JSGlobalPropertyCell::cast(value)->value();
           if (!value->IsTheHole()) return value;
           // If value is the hole do the general lookup.
         }
       }
-    } else if (FLAG_smi_only_arrays && args.at<Object>(1)->IsSmi()) {
+    } else if (args.at<Object>(1)->IsSmi()) {
+      // Getting properties from FAST_DOUBLE_ELEMENTS arrays causes boxing. To
+      // proactively avoid excessive boxing, transition FAST_DOUBLE_ELEMENTS
+      // arrays to FAST_ELEMENTS if they are accessed via this function, which
+      // is called by the KeyedLoadIC::GenericStub.
+      Handle<JSObject> js_object(args.at<JSObject>(0));
+      if (js_object->HasFastDoubleElements()) {
+        MaybeObject* maybe_object =
+            js_object->TransitionElementsKind(FAST_ELEMENTS);
+        if (maybe_object->IsFailure()) return maybe_object;
+      }
+
       // JSObject without a string key. If the key is a Smi, check for a
       // definite out-of-bounds access to elements, which is a strong indicator
       // that subsequent accesses will also call the runtime. Proactively
       // transition elements to FAST_ELEMENTS to avoid excessive boxing of
       // doubles for those future calls in the case that the elements would
       // become FAST_DOUBLE_ELEMENTS.
-      Handle<JSObject> js_object(args.at<JSObject>(0));
       ElementsKind elements_kind = js_object->GetElementsKind();
       if (elements_kind == FAST_SMI_ONLY_ELEMENTS ||
           elements_kind == FAST_DOUBLE_ELEMENTS) {
         FixedArrayBase* elements = js_object->elements();
         if (args.at<Smi>(1)->value() >= elements->length()) {
           MaybeObject* maybe_object = TransitionElements(js_object,
                                                          FAST_ELEMENTS,
                                                          isolate);
           if (maybe_object->IsFailure()) return maybe_object;
         }
@@ skipping 9363 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal