[ic] Support data handlers that represent loads from prototypes.

src/ic/ic.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ic/ic.h"
 
 #include "src/accessors.h"
 #include "src/api-arguments-inl.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 820 matching lines @@
 
 Handle<Object> LoadIC::SimpleFieldLoad(FieldIndex index) {
   if (FLAG_tf_load_ic_stub) {
     return handle(Smi::FromInt(index.GetLoadByFieldOffset()), isolate());
   }
   TRACE_HANDLER_STATS(isolate(), LoadIC_LoadFieldStub);
   LoadFieldStub stub(isolate(), index);
   return stub.GetCode();
 }
 
+Handle<Object> LoadIC::SimpleFieldLoadFromPrototype(FieldIndex index,
+                                                    Handle<Map> receiver_map,
+                                                    Handle<JSObject> holder) {
+  if (!FLAG_tf_load_ic_stub) return Handle<Object>::null();

[Jakob Kummerow, 2016/10/13 11:59:26]

nit: you probably want to make the flag non-readonly again ;-)

[Igor Sheludko, 2016/10/13 13:20:38]

We should just remove this flag once you remove the old keyed load IC
dispatcher.

+
+  DCHECK(holder->HasFastProperties());
+
+  // Primitive maps require custom handler compilation.
+  if (receiver_map->IsPrimitiveMap()) {
+    return Handle<Object>::null();
+  }
+
+  // Switch to custom compiled handler if the prototype chain contains global
+  // or dictionary objects.
+  {
+    Map* current_map = *receiver_map;
+    Map* holder_map = holder->map();
+    while (current_map != holder_map) {
+      // Only global objects and objects that do not require access
+      // checks are allowed in stubs.
+      DCHECK(current_map->IsJSGlobalProxyMap() ||
+             !current_map->is_access_check_needed());
+
+      if (current_map->IsJSGlobalObjectMap() ||
+          current_map->IsJSGlobalProxyMap() ||
+          current_map->is_dictionary_map()) {
+        return Handle<Object>::null();
+      }
+      // Go to the next object in the prototype chain.
+      JSObject* prototype = JSObject::cast(current_map->prototype());

[Jakob Kummerow, 2016/10/13 11:59:26]

nit: use a PrototypeIterator please

[Igor Sheludko, 2016/10/13 13:20:38]

Done.

+      current_map = prototype->map();
+    }
+  }
+
+  Handle<Cell> validity_cell =
+      Map::GetOrCreatePrototypeChainValidityCell(receiver_map, isolate());
+  DCHECK(!validity_cell.is_null());
+
+  Handle<Object> handler = SimpleFieldLoad(index);
+  DCHECK(handler->IsSmi());
+
+  Factory* factory = isolate()->factory();
+
+  Handle<WeakCell> holder_cell = factory->NewWeakCell(holder);
+  return isolate()->factory()->NewTuple3(validity_cell, holder_cell, handler);

[Jakob Kummerow, 2016/10/13 11:59:26]

nit: s/isolate()->factory()/factory/

[Igor Sheludko, 2016/10/13 13:20:38]

Done.

+}
 
 bool IsCompatibleReceiver(LookupIterator* lookup, Handle<Map> receiver_map) {
   DCHECK(lookup->state() == LookupIterator::ACCESSOR);
   Isolate* isolate = lookup->isolate();
   Handle<Object> accessors = lookup->GetAccessors();
   if (accessors->IsAccessorInfo()) {
     Handle<AccessorInfo> info = Handle<AccessorInfo>::cast(accessors);
     if (info->getter() != NULL &&
         !AccessorInfo::IsCompatibleReceiverMap(isolate, info, receiver_map)) {
       return false;
@@ skipping 284 matching lines @@
         TRACE_HANDLER_STATS(isolate(), LoadIC_LoadNormal);
         return isolate()->builtins()->LoadIC_Normal();
       }
 
       // -------------- Fields --------------
       if (lookup->property_details().type() == DATA) {
         FieldIndex field = lookup->GetFieldIndex();
         if (receiver_is_holder) {
           return SimpleFieldLoad(field);
         }
+        Handle<Object> handler =
+            SimpleFieldLoadFromPrototype(field, map, holder);
+        if (!handler.is_null()) {
+          return handler;
+        }
         break;  // Custom-compiled handler.
       }
 
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == DATA_CONSTANT);
       if (receiver_is_holder) {
         TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstantStub);
         LoadConstantStub stub(isolate(), lookup->GetConstantIndex());
         return stub.GetCode();
       }
@@ skipping 1744 matching lines @@
     DCHECK_EQ(LookupIterator::INTERCEPTOR, it.state());
     it.Next();
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
                                        Object::GetProperty(&it));
   }
 
   return *result;
 }
 }  // namespace internal
 }  // namespace v8