Speed up indexed interceptor handling in the LookupIterator

src/lookup.cc

 // Copyright 2014 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/lookup.h"
 
 #include "src/bootstrapper.h"
 #include "src/deoptimizer.h"
 #include "src/elements.h"
 #include "src/field-type.h"
@@ skipping 33 matching lines @@
 
   return LookupIterator(receiver, name, configuration);
 }
 
 template <bool is_element>
 void LookupIterator::Start() {
   DisallowHeapAllocation no_gc;
 
   has_property_ = false;
   state_ = NOT_FOUND;
-  number_ = DescriptorArray::kNotFound;
   holder_ = initial_holder_;
 
   JSReceiver* holder = *holder_;
   Map* map = holder->map();
 
   state_ = LookupInHolder<is_element>(map, holder);
   if (IsFound()) return;
 
   NextInternal<is_element>(map, holder);
 }
@@ skipping 38 matching lines @@
     state_ = LookupInHolder<is_element>(map, holder);
   } while (!IsFound());
 
   holder_ = handle(holder, isolate_);
 }
 
 template <bool is_element>
 void LookupIterator::RestartInternal(InterceptorState interceptor_state) {
   interceptor_state_ = interceptor_state;
   property_details_ = PropertyDetails::Empty();
+  number_ = DescriptorArray::kNotFound;
   Start<is_element>();
 }
 
 template void LookupIterator::RestartInternal<true>(InterceptorState);
 template void LookupIterator::RestartInternal<false>(InterceptorState);
 
 // static
 Handle<JSReceiver> LookupIterator::GetRootForNonJSReceiver(
     Isolate* isolate, Handle<Object> receiver, uint32_t index) {
   // Strings are the only objects with properties (only elements) directly on
@@ skipping 487 matching lines @@
     Handle<GlobalDictionary> property_dictionary =
         handle(JSObject::cast(*holder)->global_dictionary());
     PropertyCell::UpdateCell(property_dictionary, dictionary_entry(), value,
                              property_details_);
   } else {
     NameDictionary* property_dictionary = holder->property_dictionary();
     property_dictionary->ValueAtPut(dictionary_entry(), *value);
   }
 }
 
-
+template <bool is_element>
 bool LookupIterator::SkipInterceptor(JSObject* holder) {
-  auto info = GetInterceptor(holder);
+  auto info = GetInterceptor<is_element>(holder);
   // TODO(dcarney): check for symbol/can_intercept_symbols here as well.
   if (info->non_masking()) {
     switch (interceptor_state_) {
       case InterceptorState::kUninitialized:
         interceptor_state_ = InterceptorState::kSkipNonMasking;
       // Fall through.
       case InterceptorState::kSkipNonMasking:
         return true;
       case InterceptorState::kProcessNonMasking:
         return false;
@@ skipping 49 matching lines @@
     case NOT_FOUND:
       if (map->IsJSProxyMap()) {
         if (is_element || !name_->IsPrivate()) return JSPROXY;
       }
       if (map->is_access_check_needed()) {
         if (is_element || !name_->IsPrivate()) return ACCESS_CHECK;
       }
     // Fall through.
     case ACCESS_CHECK:
       if (check_interceptor() && HasInterceptor<is_element>(map) &&
-          !SkipInterceptor(JSObject::cast(holder))) {
+          !SkipInterceptor<is_element>(JSObject::cast(holder))) {
         if (is_element || !name_->IsPrivate()) return INTERCEPTOR;
       }
     // Fall through.
     case INTERCEPTOR:
       if (!is_element && map->IsJSGlobalObjectMap()) {
         GlobalDictionary* dict = JSObject::cast(holder)->global_dictionary();
         int number = dict->FindEntry(name_);
         if (number == GlobalDictionary::kNotFound) return NOT_FOUND;
         number_ = static_cast<uint32_t>(number);
         DCHECK(dict->ValueAt(number_)->IsPropertyCell());
@@ skipping 58 matching lines @@
     case v8::internal::kAccessor:
       return ACCESSOR;
   }
 
   UNREACHABLE();
   return state_;
 }
 
 }  // namespace internal
 }  // namespace v8