Encapsulate type in the PropertyHandlerCompiler

src/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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/codegen.h"
@@ skipping 921 matching lines @@
   // Use specialized code for getting prototype of functions.
   if (object->IsJSFunction() &&
       String::Equals(isolate()->factory()->prototype_string(), name) &&
       Handle<JSFunction>::cast(object)->should_have_prototype() &&
       !Handle<JSFunction>::cast(object)->map()->has_non_instance_prototype()) {
     Handle<Code> stub;
     FunctionPrototypeStub function_prototype_stub(isolate());
     return function_prototype_stub.GetCode();
   }
 
   Handle<HeapType> type = receiver_type();

[Igor Sheludko, 2014/07/30 09:19:46]

You replaced half of the |type| usages with the |receiver_type()|. What about
the other half?

   Handle<JSObject> holder(lookup->holder());
   bool receiver_is_holder = object.is_identical_to(holder);
-  NamedLoadHandlerCompiler compiler(isolate(), cache_holder);
+  NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), cache_holder);
 
   switch (lookup->type()) {
     case FIELD: {
       FieldIndex field = lookup->GetFieldIndex();
       if (receiver_is_holder) {
         return SimpleFieldLoad(field);
       }
-      return compiler.CompileLoadField(
-          type, holder, name, field, lookup->representation());
+      return compiler.CompileLoadField(holder, name, field,
+                                       lookup->representation());
     }
     case CONSTANT: {
       Handle<Object> constant(lookup->GetConstant(), isolate());
-      return compiler.CompileLoadConstant(type, holder, name, constant);
+      return compiler.CompileLoadConstant(holder, name, constant);
     }
     case NORMAL:
       if (kind() != Code::LOAD_IC) break;
       if (holder->IsGlobalObject()) {
         Handle<GlobalObject> global = Handle<GlobalObject>::cast(holder);
         Handle<PropertyCell> cell(
             global->GetPropertyCell(lookup), isolate());
-        Handle<Code> code = compiler.CompileLoadGlobal(
-            type, global, cell, name, lookup->IsDontDelete());
+        Handle<Code> code = compiler.CompileLoadGlobal(global, cell, name,
+                                                       lookup->IsDontDelete());
         // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
         CacheHolderFlag flag;
         Handle<Map> stub_holder_map =
             GetHandlerCacheHolder(*type, receiver_is_holder, isolate(), &flag);
         Map::UpdateCodeCache(stub_holder_map, name, code);
         return code;
       }
       // There is only one shared stub for loading normalized
       // properties. It does not traverse the prototype chain, so the
       // property must be found in the object for the stub to be
@@ skipping 12 matching lines @@
               object_offset, receiver->map());
           return SimpleFieldLoad(index);
         }
       }
 
       Handle<Object> callback(lookup->GetCallbackObject(), isolate());
       if (callback->IsExecutableAccessorInfo()) {
         Handle<ExecutableAccessorInfo> info =
             Handle<ExecutableAccessorInfo>::cast(callback);
         if (v8::ToCData<Address>(info->getter()) == 0) break;
-        if (!info->IsCompatibleReceiver(*object)) break;
-        return compiler.CompileLoadCallback(type, holder, name, info);
+        Handle<Map> map = TypeToMap(*receiver_type(), isolate());
+        if (info->HasExpectedReceiverType() &&
+            !info->IsCompatibleReceiver(*map)) {

[Igor Sheludko, 2014/07/30 09:19:46]

Consider 
  !info->IsCompatibleReceiver(TypeToMap(*type, isolate()))
like you did in all the other places.

What about adding IC::IsCompatibleReceiver(info, type) instead of old
AccessorInfo::IsCompatibleReceiver()?

+          break;
+        }
+        return compiler.CompileLoadCallback(holder, name, info);
       } else if (callback->IsAccessorPair()) {
         Handle<Object> getter(Handle<AccessorPair>::cast(callback)->getter(),
                               isolate());
         if (!getter->IsJSFunction()) break;
         if (holder->IsGlobalObject()) break;
         if (!holder->HasFastProperties()) break;
         Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
         if (!object->IsJSObject() &&
             !function->IsBuiltin() &&
             function->shared()->strict_mode() == SLOPPY) {
           // Calling sloppy non-builtins with a value as the receiver
           // requires boxing.
           break;
         }
         CallOptimization call_optimization(function);
         if (call_optimization.is_simple_api_call() &&
             call_optimization.IsCompatibleReceiver(object, holder)) {
-          return compiler.CompileLoadCallback(
-              type, holder, name, call_optimization);
+          return compiler.CompileLoadCallback(holder, name, call_optimization);
         }
-        return compiler.CompileLoadViaGetter(type, holder, name, function);
+        return compiler.CompileLoadViaGetter(holder, name, function);
       }
       // TODO(dcarney): Handle correctly.
       ASSERT(callback->IsDeclaredAccessorInfo());
       break;
     }
     case INTERCEPTOR:
       ASSERT(HasInterceptorGetter(*holder));
-      return compiler.CompileLoadInterceptor(type, holder, name);
+      return compiler.CompileLoadInterceptor(holder, name);
     default:
       break;
   }
 
   return slow_stub();
 }
 
 
 static Handle<Object> TryConvertKey(Handle<Object> key, Isolate* isolate) {
   // This helper implements a few common fast cases for converting
@@ skipping 344 matching lines @@
                                      Handle<Object> object, Handle<String> name,
                                      Handle<Object> value,
                                      CacheHolderFlag cache_holder) {
   if (object->IsAccessCheckNeeded()) return slow_stub();
   ASSERT(cache_holder == kCacheOnReceiver || lookup->type() == CALLBACKS ||
          (object->IsJSGlobalProxy() && lookup->holder()->IsJSGlobalObject()));
   // This is currently guaranteed by checks in StoreIC::Store.
   Handle<JSObject> receiver = Handle<JSObject>::cast(object);
 
   Handle<JSObject> holder(lookup->holder());
-  NamedStoreHandlerCompiler compiler(isolate());
+  NamedStoreHandlerCompiler compiler(isolate(), receiver_type());
 
   if (lookup->IsTransition()) {
     // Explicitly pass in the receiver map since LookupForWrite may have
     // stored something else than the receiver in the holder.
     Handle<Map> transition(lookup->GetTransitionTarget());
     PropertyDetails details = lookup->GetPropertyDetails();
 
     if (details.type() != CALLBACKS && details.attributes() == NONE) {
       return compiler.CompileStoreTransition(
           receiver, lookup, transition, name);
@@ skipping 25 matching lines @@
         }
         ASSERT(holder.is_identical_to(receiver));
         return isolate()->builtins()->StoreIC_Normal();
       case CALLBACKS: {
         Handle<Object> callback(lookup->GetCallbackObject(), isolate());
         if (callback->IsExecutableAccessorInfo()) {
           Handle<ExecutableAccessorInfo> info =
               Handle<ExecutableAccessorInfo>::cast(callback);
           if (v8::ToCData<Address>(info->setter()) == 0) break;
           if (!holder->HasFastProperties()) break;
-          if (!info->IsCompatibleReceiver(*receiver)) break;
+          Handle<Map> map = TypeToMap(*receiver_type(), isolate());
+          if (info->HasExpectedReceiverType() &&
+              !info->IsCompatibleReceiver(*map)) {

[Igor Sheludko, 2014/07/30 09:19:46]

Same here.

+            break;
+          }
           return compiler.CompileStoreCallback(receiver, holder, name, info);
         } else if (callback->IsAccessorPair()) {
           Handle<Object> setter(
               Handle<AccessorPair>::cast(callback)->setter(), isolate());
           if (!setter->IsJSFunction()) break;
           if (holder->IsGlobalObject()) break;
           if (!holder->HasFastProperties()) break;
           Handle<JSFunction> function = Handle<JSFunction>::cast(setter);
           CallOptimization call_optimization(function);
           if (call_optimization.is_simple_api_call() &&
@@ skipping 1583 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal