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

src/objects.cc

 // Copyright 2015 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/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 1338 matching lines @@
 
     PropertyCallbackArguments args(isolate, info->data(), *receiver, *holder,
                                    Object::DONT_THROW);
     Handle<Object> result = args.Call(call_fun, name);
     RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate, Object);
     if (result.is_null()) return isolate->factory()->undefined_value();
     // Rebox handle before return.
     return handle(*result, isolate);
   }
 
-  // Regular accessor.
   Handle<Object> getter(AccessorPair::cast(*structure)->getter(), isolate);
   if (getter->IsFunctionTemplateInfo()) {
-    return Builtins::InvokeApiFunction(
-        isolate, false, Handle<FunctionTemplateInfo>::cast(getter), receiver, 0,
-        nullptr, isolate->factory()->undefined_value());
+    Handle<FunctionTemplateInfo> fti =
+        Handle<FunctionTemplateInfo>::cast(getter);
+
+    // Check if the accessor is backed by a private property (surrogate
+    // accessor).
+    if (!fti->cache_property()->IsTheHole(isolate)) {
+      Handle<Name> name = handle(Name::cast(fti->cache_property()), isolate);
+
+      LookupIterator cache_it = LookupIterator::PropertyOrElement(
+          isolate, it->GetStoreTarget(), name);
+
+      // The hidden property must be set before it's accessed.
+      // This will catch setting the hidden property on the wrong object in most
+      // cases.
+      CHECK_EQ(LookupIterator::DATA, cache_it.state());
+      return Object::GetProperty(&cache_it);
+    }
+
+    // Regular accessor.
+    return Builtins::InvokeApiFunction(isolate, false, fti, receiver, 0,
+                                       nullptr,
+                                       isolate->factory()->undefined_value());
+
   } else if (getter->IsCallable()) {
     // TODO(rossberg): nicer would be to cast to some JSCallable here...
     return Object::GetPropertyWithDefinedGetter(
         receiver, Handle<JSReceiver>::cast(getter));
   }
   // Getter is not a function.
   return isolate->factory()->undefined_value();
 }
 
 // static
@@ skipping 18518 matching lines @@
     ResolveSet resolve_set(&zone);
     if (ResolveExport(module, Handle<String>::cast(name), true, &resolve_set)
             .is_null()) {
       return false;
     }
   }
 
   return true;
 }
 
+MaybeHandle<Name> FunctionTemplateInfo::TryGetCachePropertyName(
+    Isolate* isolate, Handle<Object> getter) {
+  if (getter->IsFunctionTemplateInfo()) {
+    Handle<FunctionTemplateInfo> fti =
+        Handle<FunctionTemplateInfo>::cast(getter);
+    // Check if the accessor is backed by a private property (cached accessor).
+    if (!fti->cache_property()->IsTheHole(isolate)) {
+      Handle<Name> name = handle(Name::cast(fti->cache_property()));
+      return MaybeHandle<Name>(name);
+    }
+  }
+  return MaybeHandle<Name>();
+}
+
 }  // namespace internal
 }  // namespace v8