[ic] Avoid extra prototype chain iteration when creating a load IC data handler.

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 <iostream>
 
 #include "src/accessors.h"
 #include "src/api-arguments-inl.h"
@@ skipping 897 matching lines @@
 }
 
 }  // namespace
 
 int LoadIC::GetPrototypeCheckCount(Handle<Map> receiver_map,
                                    Handle<JSObject> holder) {
   return InitPrototypeChecks<false>(isolate(), receiver_map, holder,
                                     Handle<FixedArray>(), Handle<Name>());
 }
 
-Handle<Object> LoadIC::SimpleLoadFromPrototype(Handle<Map> receiver_map,
-                                               Handle<JSObject> holder,
-                                               Handle<Name> name,
-                                               Handle<Object> smi_handler) {
+Handle<Object> LoadIC::LoadFromPrototype(Handle<Map> receiver_map,
+                                         Handle<JSObject> holder,
+                                         Handle<Name> name,
+                                         Handle<Object> smi_handler) {
   int checks_count = GetPrototypeCheckCount(receiver_map, holder);
   DCHECK_LE(0, checks_count);
 
   if (receiver_map->IsJSGlobalObjectMap()) {
     UNREACHABLE();
   } else if (receiver_map->is_dictionary_map()) {
     smi_handler =
         LoadHandler::EnableNegativeLookupOnReceiver(isolate(), smi_handler);
   }
 
@@ skipping 11 matching lines @@
   Handle<FixedArray> handler_array(isolate()->factory()->NewFixedArray(
       LoadHandler::kFirstPrototypeIndex + checks_count, TENURED));
   handler_array->set(LoadHandler::kSmiHandlerIndex, *smi_handler);
   handler_array->set(LoadHandler::kValidityCellIndex, *validity_cell);
   handler_array->set(LoadHandler::kHolderCellIndex, *holder_cell);
   InitPrototypeChecks<true>(isolate(), receiver_map, holder, handler_array,
                             name);
   return handler_array;
 }
 
-Handle<Object> LoadIC::SimpleLoadNonExistent(Handle<Map> receiver_map,
-                                             Handle<Name> name) {
+Handle<Object> LoadIC::LoadNonExistent(Handle<Map> receiver_map,
+                                       Handle<Name> name) {
   Handle<JSObject> holder;  // null handle
   int checks_count = GetPrototypeCheckCount(receiver_map, holder);
   DCHECK_LE(0, checks_count);
 
   if (receiver_map->IsJSGlobalObjectMap()) {
     UNREACHABLE();
   }
   Handle<Object> smi_handler = LoadHandler::LoadNonExistent(
       isolate(), receiver_map->is_dictionary_map());
 
@@ skipping 71 matching lines @@
     return;
   }
 
   Handle<Object> code;
   if (lookup->state() == LookupIterator::JSPROXY ||
       lookup->state() == LookupIterator::ACCESS_CHECK) {
     code = slow_stub();
   } else if (!lookup->IsFound()) {
     if (kind() == Code::LOAD_IC) {
       TRACE_HANDLER_STATS(isolate(), LoadIC_LoadNonexistentDH);
-      code = SimpleLoadNonExistent(receiver_map(), lookup->name());
+      code = LoadNonExistent(receiver_map(), lookup->name());
     } else if (kind() == Code::LOAD_GLOBAL_IC) {
       code = NamedLoadHandlerCompiler::ComputeLoadNonexistent(lookup->name(),
                                                               receiver_map());
       // TODO(jkummerow/verwaest): Introduce a builtin that handles this case.
       if (code.is_null()) code = slow_stub();
     } else {
       code = slow_stub();
     }
   } else {
     if (kind() == Code::LOAD_GLOBAL_IC &&
@@ skipping 325 matching lines @@
         return isolate()->builtins()->LoadIC_Normal();
       }
 
       // -------------- Fields --------------
       if (lookup->property_details().type() == DATA) {
         FieldIndex field = lookup->GetFieldIndex();
         Handle<Object> smi_handler = SimpleFieldLoad(field);
         if (receiver_is_holder) {
           return smi_handler;
         }
-        if (FLAG_tf_load_ic_stub && GetPrototypeCheckCount(map, holder) >= 0) {
+        if (FLAG_tf_load_ic_stub && kind() != Code::LOAD_GLOBAL_IC) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadFieldFromPrototypeDH);
-          return SimpleLoadFromPrototype(map, holder, lookup->name(),
-                                         smi_handler);
+          return LoadFromPrototype(map, holder, lookup->name(), smi_handler);
         }
         break;  // Custom-compiled handler.
       }
 
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == DATA_CONSTANT);
       if (FLAG_tf_load_ic_stub) {
         Handle<Object> smi_handler =
             LoadHandler::LoadConstant(isolate(), lookup->GetConstantIndex());
         if (receiver_is_holder) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstantDH);
           return smi_handler;
         }
-        if (GetPrototypeCheckCount(map, holder) >= 0) {
+        if (kind() != Code::LOAD_GLOBAL_IC) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstantFromPrototypeDH);
-          return SimpleLoadFromPrototype(map, holder, lookup->name(),
-                                         smi_handler);
+          return LoadFromPrototype(map, holder, lookup->name(), smi_handler);
         }
       } else {
         if (receiver_is_holder) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstantStub);
           LoadConstantStub stub(isolate(), lookup->GetConstantIndex());
           return stub.GetCode();
         }
       }
       break;  // Custom-compiled handler.
     }
@@ skipping 1751 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