Encapsulate the holder in the PropertyHolderCompilers

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 185 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, type, flag);
-  handler = compiler.CompileLoadNonexistent(last, cache_name);
+  NamedLoadHandlerCompiler compiler(isolate, type, last, flag);
+  handler = compiler.CompileLoadNonexistent(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 524 matching lines @@
   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(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())) {
     function_index = Context::STRING_FUNCTION_INDEX;
   } else if (type()->Is(HeapType::Symbol())) {
     function_index = Context::SYMBOL_FUNCTION_INDEX;
   } else if (type()->Is(HeapType::Number())) {
     function_index = Context::NUMBER_FUNCTION_INDEX;
   } 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();
     set_type_for_object(handle(prototype, isolate()));
     object_reg = scratch1();
   }
 
   // Check that the maps starting from the prototype haven't changed.
-  return CheckPrototypes(object_reg, holder, scratch1(), scratch2(), scratch3(),
-                         name, miss, check_type);
+  return CheckPrototypes(object_reg, 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(Register object_reg,
-                                                   Handle<JSObject> holder,
                                                    Handle<Name> name,
                                                    Label* miss) {
-  return CheckPrototypes(object_reg, holder, this->name(), scratch1(),
-                         scratch2(), name, miss, SKIP_RECEIVER);
+  return CheckPrototypes(object_reg, 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(Register object_reg,
-                                           Handle<JSObject> holder,
                                            Handle<Name> name) {
   Label miss;
-  Register reg = FrontendHeader(object_reg, holder, name, &miss);
+  Register reg = FrontendHeader(object_reg, name, &miss);
   FrontendFooter(name, &miss);
   return reg;
 }
 
 
-void NamedLoadHandlerCompiler::NonexistentFrontend(Handle<JSObject> last,
-                                                   Handle<Name> name) {
+void NamedLoadHandlerCompiler::NonexistentFrontend(Handle<Name> name) {
   Label miss;
 
-  Register holder;
+  Register holder_reg;
   Handle<Map> last_map;
-  if (last.is_null()) {
-    holder = receiver();
+  if (holder().is_null()) {
+    holder_reg = receiver();
     last_map = IC::TypeToMap(*type(), isolate());
-    // If |type| has null as its prototype, |last| is Handle<JSObject>::null().
+    // If |type| has null as its prototype, |holder()| is
+    // Handle<JSObject>::null().
     ASSERT(last_map->prototype() == isolate()->heap()->null_value());
   } else {
-    holder = FrontendHeader(receiver(), last, name, &miss);
-    last_map = handle(last->map());
+    holder_reg = FrontendHeader(receiver(), name, &miss);
+    last_map = handle(holder()->map());
   }
 
-  if (last_map->is_dictionary_map() &&
-      !last_map->IsJSGlobalObjectMap() &&
-      !last_map->IsJSGlobalProxyMap()) {
+  if (last_map->is_dictionary_map() && !last_map->IsJSGlobalObjectMap()) {
     if (!name->IsUniqueName()) {
       ASSERT(name->IsString());
       name = factory()->InternalizeString(Handle<String>::cast(name));
     }
-    ASSERT(last.is_null() ||
-           last->property_dictionary()->FindEntry(name) ==
+    ASSERT(holder().is_null() ||
+           holder()->property_dictionary()->FindEntry(name) ==
                NameDictionary::kNotFound);
-    GenerateDictionaryNegativeLookup(masm(), &miss, holder, name,
+    GenerateDictionaryNegativeLookup(masm(), &miss, holder_reg, 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()
+        holder().is_null()
             ? Handle<JSGlobalObject>::cast(type()->AsConstant()->Value())
-            : Handle<JSGlobalObject>::cast(last);
+            : Handle<JSGlobalObject>::cast(holder());
     GenerateCheckPropertyCell(masm(), global, name, scratch2(), &miss);
   }
 
   FrontendFooter(name, &miss);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadField(
-    Handle<JSObject> holder, Handle<Name> name, FieldIndex field,
-    Representation representation) {
-  Register reg = Frontend(receiver(), holder, name);
-  GenerateLoadField(reg, holder, field, representation);
+    Handle<Name> name, FieldIndex field, Representation representation) {
+  Register reg = Frontend(receiver(), name);
+  GenerateLoadField(reg, field, representation);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadConstant(
-    Handle<JSObject> holder, Handle<Name> name, Handle<Object> value) {
-  Frontend(receiver(), holder, name);
+    Handle<Name> name, Handle<Object> value) {
+  Frontend(receiver(), name);
   GenerateLoadConstant(value);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
-    Handle<JSObject> holder, Handle<Name> name,
-    Handle<ExecutableAccessorInfo> callback) {
-  Register reg = CallbackFrontend(receiver(), holder, name, callback);
+    Handle<Name> name, Handle<ExecutableAccessorInfo> callback) {
+  Register reg = CallbackFrontend(receiver(), name, callback);
   GenerateLoadCallback(reg, callback);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
-    Handle<JSObject> holder, Handle<Name> name,
-    const CallOptimization& call_optimization) {
+    Handle<Name> name, const CallOptimization& call_optimization) {
   ASSERT(call_optimization.is_simple_api_call());
   Handle<JSFunction> callback = call_optimization.constant_function();
-  CallbackFrontend(receiver(), holder, name, callback);
+  CallbackFrontend(receiver(), 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<JSObject> holder, Handle<Name> name) {
+    Handle<Name> name) {
   // Perform a lookup after the interceptor.
   LookupResult lookup(isolate());
-  holder->LookupOwnRealNamedProperty(name, &lookup);
+  holder()->LookupOwnRealNamedProperty(name, &lookup);
   if (!lookup.IsFound()) {
-    PrototypeIterator iter(holder->GetIsolate(), holder);
+    PrototypeIterator iter(holder()->GetIsolate(), holder());
     if (!iter.IsAtEnd()) {
       PrototypeIterator::GetCurrent(iter)->Lookup(name, &lookup);
     }
   }
 
-  Register reg = Frontend(receiver(), holder, name);
+  Register reg = Frontend(receiver(), name);
   // TODO(368): Compile in the whole chain: all the interceptors in
   // prototypes and ultimate answer.
-  GenerateLoadInterceptor(reg, holder, &lookup, name);
+  GenerateLoadInterceptor(reg, &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());
+    Register interceptor_reg, Handle<Name> name, LookupResult* lookup) {
+  Handle<JSObject> real_named_property_holder(lookup->holder());
   if (lookup->IsField()) {
     FieldIndex field = lookup->GetFieldIndex();
-    if (interceptor_holder.is_identical_to(holder)) {
-      GenerateLoadField(
-          interceptor_reg, holder, field, lookup->representation());
+    if (holder().is_identical_to(real_named_property_holder)) {
+      GenerateLoadField(interceptor_reg, field, lookup->representation());
     } else {
-      // We found FIELD property in prototype chain of interceptor's holder.
-      // Retrieve a field from field's holder.
-      set_type_for_object(interceptor_holder);
-      Register reg = Frontend(interceptor_reg, holder, name);
-      GenerateLoadField(
-          reg, holder, field, lookup->representation());
+      set_type_for_object(holder());
+      set_holder(real_named_property_holder);
+      Register reg = Frontend(interceptor_reg, name);
+      GenerateLoadField(reg, field, lookup->representation());
     }
   } else {
-    // We found CALLBACKS property in prototype chain of interceptor's
-    // holder.
+    // 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);
 
-    set_type_for_object(interceptor_holder);
-    Register reg = CallbackFrontend(interceptor_reg, holder, name, callback);
+    set_type_for_object(holder());
+    set_holder(real_named_property_holder);
+    Register reg = CallbackFrontend(interceptor_reg, 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<JSObject> holder, Handle<Name> name, Handle<JSFunction> getter) {
-  Frontend(receiver(), holder, name);
+    Handle<Name> name, Handle<JSFunction> getter) {
+  Frontend(receiver(), name);
   GenerateLoadViaGetter(masm(), type(), receiver(), getter);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
+// TODO(verwaest): Cleanup. holder() is actually the receiver.
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreTransition(
-    Handle<JSObject> object, LookupResult* lookup, Handle<Map> transition,
-    Handle<Name> name) {
+    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());
-    }
+  bool is_nonexistent = holder()->map() == transition->GetBackPointer();
+  if (is_nonexistent) {
+    // Find the top object.
+    Handle<JSObject> last;
+    PrototypeIterator iter(isolate(), holder());
+    do {
+      last = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
+      iter.Advance();
+    } while (!iter.IsAtEnd());
+    set_holder(last);
+  }
 
-    Register holder_reg = FrontendHeader(receiver(), holder, name, &miss);
+  Register holder_reg = FrontendHeader(receiver(), 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);
-    }
+  // 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 (is_nonexistent) {
+    GenerateNegativeHolderLookup(masm(), holder(), holder_reg, name, &miss);
   }
 
   GenerateStoreTransition(masm(),
-                          object,
                           lookup,
                           transition,
                           name,
                           receiver(), this->name(), value(),
                           scratch1(), scratch2(), scratch3(),
                           &miss,
                           &slow);
 
   // Handle store cache miss.
   GenerateRestoreName(masm(), &miss, name);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
 
   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) {
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreField(LookupResult* lookup,
+                                                          Handle<Name> name) {
   Label miss;
 
-  FrontendHeader(receiver(), object, name, &miss);
+  FrontendHeader(receiver(), name, &miss);
 
   // Generate store field code.
-  GenerateStoreField(masm(),
-                     object,
-                     lookup,
-                     receiver(), this->name(), value(), scratch1(), scratch2(),
-                     &miss);
+  GenerateStoreField(masm(), holder(), lookup, receiver(), this->name(),
+                     value(), scratch1(), scratch2(), &miss);
 
   // Handle store cache miss.
   __ bind(&miss);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreArrayLength(
-    Handle<JSObject> object, LookupResult* lookup, Handle<Name> name) {
+    LookupResult* lookup, Handle<Name> name) {
   // This accepts as a receiver anything JSArray::SetElementsLength accepts
   // (currently anything except for external arrays which means anything with
   // elements of FixedArray type).  Value must be a number, but only smis are
   // accepted as the most common case.
   Label miss;
 
   // Check that value is a smi.
   __ JumpIfNotSmi(value(), &miss);
 
   // Generate tail call to StoreIC_ArrayLength.
   GenerateStoreArrayLength();
 
   // 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) {
-  Frontend(receiver(), holder, name);
+    Handle<JSObject> object, Handle<Name> name, Handle<JSFunction> setter) {
+  Frontend(receiver(), 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,
+    Handle<JSObject> object, Handle<Name> name,
     const CallOptimization& call_optimization) {
-  Frontend(receiver(), holder, name);
+  Frontend(receiver(), 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