Speedup global_proxy.* attributes/accessors (specialize GlobalProxy access).

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 1223 matching lines @@
                                                  &object_offset));
 #endif
 
       DCHECK(IsCompatibleReceiver(lookup, map));
       Handle<Object> accessors = lookup->GetAccessors();
       if (accessors->IsAccessorPair()) {
         DCHECK(holder->HasFastProperties());
         DCHECK(!GetSharedFunctionInfo()->HasDebugInfo());
         Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
                               isolate());
+
+        MaybeHandle<Name> maybe_name =
+            FunctionTemplateInfo::TryGetCachePropertyName(isolate(), getter);
+        if (!maybe_name.is_null()) {
+          Handle<Name> name = maybe_name.ToHandleChecked();
+          LookupIterator cache_it(lookup->GetReceiver(), name, holder);
+          CHECK_EQ(LookupIterator::DATA, cache_it.state());
+          return CompileHandler(&cache_it, unused, cache_holder);
+        }
+
         CallOptimization call_optimization(getter);
         NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
         if (call_optimization.is_simple_api_call()) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
           int index = lookup->GetAccessorIndex();
           Handle<Code> code = compiler.CompileLoadCallback(
               lookup->name(), call_optimization, index, slow_stub());
           return code;
         }
         TRACE_HANDLER_STATS(isolate(), LoadIC_LoadViaGetter);
@@ skipping 27 matching lines @@
         NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
         Handle<PropertyCell> cell = lookup->GetPropertyCell();
         Handle<Code> code = compiler.CompileLoadGlobal(
             cell, lookup->name(), lookup->IsConfigurable());
         return code;
       }
 
       // -------------- Fields --------------
       if (lookup->property_details().type() == DATA) {
         FieldIndex field = lookup->GetFieldIndex();
-        DCHECK(!receiver_is_holder);
         TRACE_HANDLER_STATS(isolate(), LoadIC_LoadField);
         NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
         return compiler.CompileLoadField(lookup->name(), field);
       }
 
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == DATA_CONSTANT);
       DCHECK(!receiver_is_holder);
       TRACE_HANDLER_STATS(isolate(), LoadIC_LoadConstant);
       NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
@@ skipping 1618 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