Encapsulate type in the PropertyHandlerCompiler

src/stub-cache.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/api.h"
 #include "src/arguments.h"
 #include "src/ast.h"
 #include "src/code-stubs.h"
@@ skipping 180 matching lines @@
     if (current_map->prototype()->IsNull()) break;
     last = handle(JSObject::cast(current_map->prototype()));
     current_map = handle(last->map());
   }
   // Compile the stub that is either shared for all names or
   // name specific if there are global objects involved.
   Handle<Code> handler = PropertyHandlerCompiler::Find(
       cache_name, stub_holder_map, Code::LOAD_IC, flag, Code::FAST);
   if (!handler.is_null()) return handler;
 
-  NamedLoadHandlerCompiler compiler(isolate, flag);
-  handler = compiler.CompileLoadNonexistent(type, last, cache_name);
+  NamedLoadHandlerCompiler compiler(isolate, type, flag);
+  handler = compiler.CompileLoadNonexistent(last, cache_name);
   Map::UpdateCodeCache(stub_holder_map, cache_name, handler);
   return handler;
 }
 
 
 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphic(
     Handle<Map> receiver_map) {
   Isolate* isolate = receiver_map->GetIsolate();
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
   Handle<Name> name = isolate->factory()->KeyedLoadMonomorphic_string();
@@ skipping 279 matching lines @@
 
 
 RUNTIME_FUNCTION(StoreCallbackProperty) {
   JSObject* receiver = JSObject::cast(args[0]);
   JSObject* holder = JSObject::cast(args[1]);
   ExecutableAccessorInfo* callback = ExecutableAccessorInfo::cast(args[2]);
   Address setter_address = v8::ToCData<Address>(callback->setter());
   v8::AccessorSetterCallback fun =
       FUNCTION_CAST<v8::AccessorSetterCallback>(setter_address);
   ASSERT(fun != NULL);
-  ASSERT(callback->IsCompatibleReceiver(receiver));
   Handle<Name> name = args.at<Name>(3);
   Handle<Object> value = args.at<Object>(4);
   HandleScope scope(isolate);
+  ASSERT(!callback->HasExpectedReceiverType() ||
+         callback->IsCompatibleReceiver(receiver->map()));
 
   // TODO(rossberg): Support symbols in the API.
   if (name->IsSymbol()) return *value;
   Handle<String> str = Handle<String>::cast(name);
 
   LOG(isolate, ApiNamedPropertyAccess("store", receiver, *name));
   PropertyCallbackArguments
       custom_args(isolate, callback->data(), receiver, holder);
   custom_args.Call(fun, v8::Utils::ToLocal(str), v8::Utils::ToLocal(value));
   RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
@@ skipping 218 matching lines @@
                                                       Handle<Name> name) {
   return (FLAG_print_code_stubs && !name.is_null() && name->IsString())
       ? GetCodeWithFlags(flags, Handle<String>::cast(name)->ToCString().get())
       : GetCodeWithFlags(flags, NULL);
 }
 
 
 #define __ ACCESS_MASM(masm())
 
 
-Register NamedLoadHandlerCompiler::FrontendHeader(Handle<HeapType> type,
-                                                  Register object_reg,
+Register NamedLoadHandlerCompiler::FrontendHeader(Register object_reg,
                                                   Handle<JSObject> holder,
                                                   Handle<Name> name,
                                                   Label* miss) {
   PrototypeCheckType check_type = CHECK_ALL_MAPS;
   int function_index = -1;
-  if (type->Is(HeapType::String())) {
+  if (type()->Is(HeapType::String())) {
     function_index = Context::STRING_FUNCTION_INDEX;
-  } else if (type->Is(HeapType::Symbol())) {
+  } else if (type()->Is(HeapType::Symbol())) {
     function_index = Context::SYMBOL_FUNCTION_INDEX;
-  } else if (type->Is(HeapType::Number())) {
+  } else if (type()->Is(HeapType::Number())) {
     function_index = Context::NUMBER_FUNCTION_INDEX;
-  } else if (type->Is(HeapType::Boolean())) {
+  } else if (type()->Is(HeapType::Boolean())) {
     function_index = Context::BOOLEAN_FUNCTION_INDEX;
   } else {
     check_type = SKIP_RECEIVER;
   }
 
   if (check_type == CHECK_ALL_MAPS) {
     GenerateDirectLoadGlobalFunctionPrototype(
         masm(), function_index, scratch1(), miss);
     Object* function = isolate()->native_context()->get(function_index);
     Object* prototype = JSFunction::cast(function)->instance_prototype();
-    type = IC::CurrentTypeOf(handle(prototype, isolate()), isolate());
+    set_type_for_object(handle(prototype, isolate()));
     object_reg = scratch1();
   }
 
   // Check that the maps starting from the prototype haven't changed.
-  return CheckPrototypes(
-      type, object_reg, holder, scratch1(), scratch2(), scratch3(),
-      name, miss, check_type);
+  return CheckPrototypes(object_reg, holder, scratch1(), scratch2(), scratch3(),
+                         name, miss, check_type);
 }
 
 
 // Frontend for store uses the name register. It has to be restored before a
 // miss.
-Register NamedStoreHandlerCompiler::FrontendHeader(Handle<HeapType> type,
-                                                   Register object_reg,
+Register NamedStoreHandlerCompiler::FrontendHeader(Register object_reg,
                                                    Handle<JSObject> holder,
                                                    Handle<Name> name,
                                                    Label* miss) {
-  return CheckPrototypes(type, object_reg, holder, this->name(),
-                         scratch1(), scratch2(), name, miss, SKIP_RECEIVER);
+  return CheckPrototypes(object_reg, holder, this->name(), scratch1(),
+                         scratch2(), name, miss, SKIP_RECEIVER);
 }
 
 
 bool PropertyICCompiler::IncludesNumberType(TypeHandleList* types) {
   for (int i = 0; i < types->length(); ++i) {
     if (types->at(i)->Is(HeapType::Number())) return true;
   }
   return false;
 }
 
 
-Register PropertyHandlerCompiler::Frontend(Handle<HeapType> type,
-                                           Register object_reg,
+Register PropertyHandlerCompiler::Frontend(Register object_reg,
                                            Handle<JSObject> holder,
                                            Handle<Name> name) {
   Label miss;
-  Register reg = FrontendHeader(type, object_reg, holder, name, &miss);
+  Register reg = FrontendHeader(object_reg, holder, name, &miss);
   FrontendFooter(name, &miss);
   return reg;
 }
 
 
-void NamedLoadHandlerCompiler::NonexistentFrontend(Handle<HeapType> type,
-                                                   Handle<JSObject> last,
+void NamedLoadHandlerCompiler::NonexistentFrontend(Handle<JSObject> last,
                                                    Handle<Name> name) {
   Label miss;
 
   Register holder;
   Handle<Map> last_map;
   if (last.is_null()) {
     holder = receiver();
-    last_map = IC::TypeToMap(*type, isolate());
+    last_map = IC::TypeToMap(*type(), isolate());
     // If |type| has null as its prototype, |last| is Handle<JSObject>::null().
     ASSERT(last_map->prototype() == isolate()->heap()->null_value());
   } else {
-    holder = FrontendHeader(type, receiver(), last, name, &miss);
+    holder = FrontendHeader(receiver(), last, name, &miss);
     last_map = handle(last->map());
   }
 
   if (last_map->is_dictionary_map() &&
       !last_map->IsJSGlobalObjectMap() &&
       !last_map->IsJSGlobalProxyMap()) {
     if (!name->IsUniqueName()) {
       ASSERT(name->IsString());
       name = factory()->InternalizeString(Handle<String>::cast(name));
     }
     ASSERT(last.is_null() ||
            last->property_dictionary()->FindEntry(name) ==
                NameDictionary::kNotFound);
     GenerateDictionaryNegativeLookup(masm(), &miss, holder, name,
                                      scratch2(), scratch3());
   }
 
   // If the last object in the prototype chain is a global object,
   // check that the global property cell is empty.
   if (last_map->IsJSGlobalObjectMap()) {
-    Handle<JSGlobalObject> global = last.is_null()
-        ? Handle<JSGlobalObject>::cast(type->AsConstant()->Value())
-        : Handle<JSGlobalObject>::cast(last);
+    Handle<JSGlobalObject> global =
+        last.is_null()
+            ? Handle<JSGlobalObject>::cast(type()->AsConstant()->Value())
+            : Handle<JSGlobalObject>::cast(last);
     GenerateCheckPropertyCell(masm(), global, name, scratch2(), &miss);
   }
 
   FrontendFooter(name, &miss);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadField(
-    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
-    FieldIndex field, Representation representation) {
-  Register reg = Frontend(type, receiver(), holder, name);
+    Handle<JSObject> holder, Handle<Name> name, FieldIndex field,
+    Representation representation) {
+  Register reg = Frontend(receiver(), holder, name);
   GenerateLoadField(reg, holder, field, representation);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadConstant(
-    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
-    Handle<Object> value) {
-  Frontend(type, receiver(), holder, name);
+    Handle<JSObject> holder, Handle<Name> name, Handle<Object> value) {
+  Frontend(receiver(), holder, name);
   GenerateLoadConstant(value);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
-    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
+    Handle<JSObject> holder, Handle<Name> name,
     Handle<ExecutableAccessorInfo> callback) {
-  Register reg = CallbackFrontend(type, receiver(), holder, name, callback);
+  Register reg = CallbackFrontend(receiver(), holder, name, callback);
   GenerateLoadCallback(reg, callback);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
-    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
+    Handle<JSObject> holder, Handle<Name> name,
     const CallOptimization& call_optimization) {
   ASSERT(call_optimization.is_simple_api_call());
   Handle<JSFunction> callback = call_optimization.constant_function();
-  CallbackFrontend(type, receiver(), holder, name, callback);
-  Handle<Map>receiver_map = IC::TypeToMap(*type, isolate());
+  CallbackFrontend(receiver(), holder, name, callback);
+  Handle<Map> receiver_map = IC::TypeToMap(*type(), isolate());
   GenerateFastApiCall(
       masm(), call_optimization, receiver_map,
       receiver(), scratch1(), false, 0, NULL);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadInterceptor(
-    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name) {
+    Handle<JSObject> holder, Handle<Name> name) {
   // Perform a lookup after the interceptor.
   LookupResult lookup(isolate());
   holder->LookupOwnRealNamedProperty(name, &lookup);
   if (!lookup.IsFound()) {
     PrototypeIterator iter(holder->GetIsolate(), holder);
     if (!iter.IsAtEnd()) {
       PrototypeIterator::GetCurrent(iter)->Lookup(name, &lookup);
     }
   }
 
-  Register reg = Frontend(type, receiver(), holder, name);
+  Register reg = Frontend(receiver(), holder, name);
   // TODO(368): Compile in the whole chain: all the interceptors in
   // prototypes and ultimate answer.
-  GenerateLoadInterceptor(reg, type, holder, &lookup, name);
+  GenerateLoadInterceptor(reg, holder, &lookup, name);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 void NamedLoadHandlerCompiler::GenerateLoadPostInterceptor(
     Register interceptor_reg, Handle<JSObject> interceptor_holder,
     Handle<Name> name, LookupResult* lookup) {
   Handle<JSObject> holder(lookup->holder());
   if (lookup->IsField()) {
     FieldIndex field = lookup->GetFieldIndex();
     if (interceptor_holder.is_identical_to(holder)) {
       GenerateLoadField(
           interceptor_reg, holder, field, lookup->representation());
     } else {
       // We found FIELD property in prototype chain of interceptor's holder.
       // Retrieve a field from field's holder.
-      Register reg = Frontend(IC::CurrentTypeOf(interceptor_holder, isolate()),
-                              interceptor_reg, holder, name);
+      set_type_for_object(interceptor_holder);
+      Register reg = Frontend(interceptor_reg, holder, name);
       GenerateLoadField(
           reg, holder, field, lookup->representation());
     }
   } else {
     // We found CALLBACKS property in prototype chain of interceptor's
     // holder.
     ASSERT(lookup->type() == CALLBACKS);
     Handle<ExecutableAccessorInfo> callback(
         ExecutableAccessorInfo::cast(lookup->GetCallbackObject()));
     ASSERT(callback->getter() != NULL);
 
-    Register reg =
-        CallbackFrontend(IC::CurrentTypeOf(interceptor_holder, isolate()),
-                         interceptor_reg, holder, name, callback);
+    set_type_for_object(interceptor_holder);
+    Register reg = CallbackFrontend(interceptor_reg, holder, name, callback);
     GenerateLoadCallback(reg, callback);
   }
 }
 
 
 Handle<Code> PropertyICCompiler::CompileMonomorphic(Handle<HeapType> type,
                                                     Handle<Code> handler,
                                                     Handle<Name> name,
                                                     IcCheckType check) {
   TypeHandleList types(1);
   CodeHandleList handlers(1);
   types.Add(type);
   handlers.Add(handler);
   Code::StubType stub_type = handler->type();
   return CompilePolymorphic(&types, &handlers, name, stub_type, check);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadViaGetter(
-    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
-    Handle<JSFunction> getter) {
-  Frontend(type, receiver(), holder, name);
-  GenerateLoadViaGetter(masm(), type, receiver(), getter);
+    Handle<JSObject> holder, Handle<Name> name, Handle<JSFunction> getter) {
+  Frontend(receiver(), holder, name);
+  GenerateLoadViaGetter(masm(), type(), receiver(), getter);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreTransition(
     Handle<JSObject> object, LookupResult* lookup, Handle<Map> transition,
     Handle<Name> name) {
   Label miss, slow;
 
   // Ensure no transitions to deprecated maps are followed.
   __ CheckMapDeprecated(transition, scratch1(), &miss);
 
   // Check that we are allowed to write this.
   PrototypeIterator iter(object->GetIsolate(), object);
   if (!iter.IsAtEnd()) {
     Handle<JSObject> holder;
     // holder == object indicates that no property was found.
     if (lookup->holder() != *object) {
       holder = Handle<JSObject>(lookup->holder());
     } else {
       // Find the top object.
       do {
         holder = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
         iter.Advance();
       } while (!iter.IsAtEnd());
     }
 
-    Register holder_reg = FrontendHeader(IC::CurrentTypeOf(object, isolate()),
-                                         receiver(), holder, name, &miss);
+    Register holder_reg = FrontendHeader(receiver(), holder, name, &miss);
 
     // If no property was found, and the holder (the last object in the
     // prototype chain) is in slow mode, we need to do a negative lookup on the
     // holder.
     if (lookup->holder() == *object) {
       GenerateNegativeHolderLookup(masm(), holder, holder_reg, name, &miss);
     }
   }
 
   GenerateStoreTransition(masm(),
@@ skipping 13 matching lines @@
   GenerateRestoreName(masm(), &slow, name);
   TailCallBuiltin(masm(), SlowBuiltin(kind()));
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreField(
     Handle<JSObject> object, LookupResult* lookup, Handle<Name> name) {
   Label miss;
 
-  FrontendHeader(IC::CurrentTypeOf(object, isolate()), receiver(), object, name,
-                 &miss);
+  FrontendHeader(receiver(), object, name, &miss);
 
   // Generate store field code.
   GenerateStoreField(masm(),
                      object,
                      lookup,
                      receiver(), this->name(), value(), scratch1(), scratch2(),
                      &miss);
 
   // Handle store cache miss.
   __ bind(&miss);
@@ skipping 19 matching lines @@
   // Handle miss case.
   __ bind(&miss);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreViaSetter(
     Handle<JSObject> object, Handle<JSObject> holder, Handle<Name> name,
     Handle<JSFunction> setter) {
-  Handle<HeapType> type = IC::CurrentTypeOf(object, isolate());
-  Frontend(type, receiver(), holder, name);
-  GenerateStoreViaSetter(masm(), type, receiver(), setter);
+  Frontend(receiver(), holder, name);
+  GenerateStoreViaSetter(masm(), type(), receiver(), setter);
 
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
     Handle<JSObject> object, Handle<JSObject> holder, Handle<Name> name,
     const CallOptimization& call_optimization) {
-  Frontend(IC::CurrentTypeOf(object, isolate()), receiver(), holder, name);
+  Frontend(receiver(), holder, name);
   Register values[] = { value() };
   GenerateFastApiCall(
       masm(), call_optimization, handle(object->map()),
       receiver(), scratch1(), true, 1, values);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> PropertyICCompiler::CompileKeyedStoreMonomorphic(
     Handle<Map> receiver_map, KeyedAccessStoreMode store_mode) {
@@ skipping 259 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal