Correct handling of arrays with callbacks in the prototype chain.

src/ic.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 1951 matching lines @@
       // expect to be able to trap element sets to objects with those maps in
       // the runtime to enable optimization of element hole access.
       Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
       if (heap_object->map()->IsMapInArrayPrototypeChain()) use_ic = false;
     }
 
     if (use_ic) {
       ASSERT(!object->IsJSGlobalProxy());
 
       if (miss_mode != MISS_FORCE_GENERIC) {
-        if (object->IsJSObject()) {
-          Handle<JSObject> receiver = Handle<JSObject>::cast(object);
-          bool key_is_smi_like = key->IsSmi() || !key->ToSmi()->IsFailure();
-          if (receiver->elements()->map() ==
-              isolate()->heap()->non_strict_arguments_elements_map()) {
-            stub = non_strict_arguments_stub();
-          } else if (key_is_smi_like &&
-                     (!target().is_identical_to(non_strict_arguments_stub()))) {
-            KeyedAccessStoreMode store_mode =
-                GetStoreMode(receiver, key, value);
-            stub = StoreElementStub(receiver, store_mode);
+        bool indexed_callbacks = false;
+        if (object->IsJSReceiver()) {
+          Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(object);
+          indexed_callbacks =
+              receiver->map()->MayHaveIndexedCallbacksInPrototypeChain();
+        }
+
+        if (!indexed_callbacks) {
+          if (object->IsJSObject()) {

[danno, 2013/10/30 12:17:45]

You should only have to check for JSObject once at this logic below
MISS_FORCE_GENERIC, and then only do the logic below:

if (receiver->map()->MayHaveIndexedCallbacksInPrototypeChain()) {
 ...
}

Might make things a little cleaner.

[mvstanton, 2013/10/30 18:22:28]

Done.

+            Handle<JSObject> receiver = Handle<JSObject>::cast(object);
+            bool key_is_smi_like = key->IsSmi() || !key->ToSmi()->IsFailure();
+            if (receiver->elements()->map() ==
+                isolate()->heap()->non_strict_arguments_elements_map()) {
+              stub = non_strict_arguments_stub();
+            } else if (key_is_smi_like &&
+                       !target().is_identical_to(non_strict_arguments_stub())) {
+              KeyedAccessStoreMode store_mode = GetStoreMode(
+                  receiver, key, value);
+              stub = StoreElementStub(receiver, store_mode);
+            } else {
+              TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "key not a number");

[danno, 2013/10/30 12:17:45]

Remove the TRACE_GENERIC_IC here and below, it's covered by Hannes' new code on
line 2007.

[mvstanton, 2013/10/30 18:22:28]

Okay, it is nice to see the reason for going generic, but I'll go for simplicity
now.

+            }
+          } else {
+            TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "not an object");
           }
+        } else {
+          TRACE_GENERIC_IC(isolate(), "KeyedStoreIC",
+                           "indexed callbacks in prototype chain");
         }
       }
     }
   }
 
   if (!is_target_set()) {
     if (*stub == *generic_stub()) {
       TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "set generic");
     }
     ASSERT(!stub.is_null());
@@ skipping 269 matching lines @@
   ic.UpdateState(receiver, key);
   return ic.Store(receiver, key, args.at<Object>(2), MISS_FORCE_GENERIC);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 4);
   KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
   Handle<Object> value = args.at<Object>(0);
+  Handle<Map> map = args.at<Map>(1);
   Handle<Object> key = args.at<Object>(2);
   Handle<Object> object = args.at<Object>(3);
   StrictModeFlag strict_mode = ic.strict_mode();
+  if (object->IsJSObject()) {
+    JSObject::TransitionElementsKind(Handle<JSObject>::cast(object),
+                                     map->elements_kind());
+  }
   return Runtime::SetObjectProperty(isolate,
                                     object,
                                     key,
                                     value,
                                     NONE,
                                     strict_mode);
 }
 
 
 const char* BinaryOpIC::GetName(TypeInfo type_info) {
@@ skipping 440 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal