V8 support for cached accessors.

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 1261 matching lines @@
     }
 
     case LookupIterator::ACCESSOR: {
 #ifdef DEBUG
       int object_offset;
       DCHECK(!Accessors::IsJSObjectFieldAccessor(map, lookup->name(),
                                                  &object_offset));
 #endif
 
       DCHECK(IsCompatibleReceiver(lookup, map));
+      if (lookup->TryLookupCacheProperty()) {

[Toon Verwaest, 2016/10/21 08:22:14]

Shouldn't this be moved in the IsAccessorPair case?

[vogelheim, 2016/11/03 16:12:23]

Done.

+        DCHECK_EQ(LookupIterator::DATA, lookup->state());
+        return CompileHandler(lookup, unused, cache_holder);

[Toon Verwaest, 2016/10/21 08:22:14]

Don't we have to go through ComputeHandler again?

[vogelheim, 2016/11/03 16:12:23]

Done.

+      }
       Handle<Object> accessors = lookup->GetAccessors();
       if (accessors->IsAccessorPair()) {
         DCHECK(holder->HasFastProperties());
         DCHECK(!GetSharedFunctionInfo()->HasDebugInfo());
         Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
                               isolate());
         CallOptimization call_optimization(getter);
         NamedLoadHandlerCompiler compiler(isolate(), map, holder, cache_holder);
         if (call_optimization.is_simple_api_call()) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
@@ skipping 33 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);

[Toon Verwaest, 2016/10/21 08:22:14]

Why is this removed? I'm pretty sure we need this. If this DCHECK fails, it's
probably not correct.

[vogelheim, 2016/11/03 16:12:23]

Done.

(I guess this was an artefact of the Comp[ile|ute]Handler thing above, and was
resolved by calling ComputeHandler.)

         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 1619 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