Introduce a PrototypeIterator template and use it all over the place

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"
 #include "src/cpu-profiler.h"
 #include "src/gdb-jit.h"
 #include "src/ic-inl.h"
+#include "src/prototype-iterator.h"
 #include "src/stub-cache.h"
 #include "src/type-info.h"
 #include "src/vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------
 // StubCache implementation.
 
@@ skipping 675 matching lines @@
       ? GetCodeWithFlags(flags, Handle<String>::cast(name)->ToCString().get())
       : GetCodeWithFlags(flags, NULL);
 }
 
 
 void StubCompiler::LookupPostInterceptor(Handle<JSObject> holder,
                                          Handle<Name> name,
                                          LookupResult* lookup) {
   holder->LookupOwnRealNamedProperty(name, lookup);
   if (lookup->IsFound()) return;
-  if (holder->GetPrototype()->IsNull()) return;
-  holder->GetPrototype()->Lookup(name, lookup);
+  if (SAFE_GET_PROTOTYPE_FAST(*holder)->IsNull()) return;
+  SAFE_GET_PROTOTYPE_FAST(*holder)->Lookup(name, lookup);
 }
 
 
 #define __ ACCESS_MASM(masm())
 
 
 Register LoadStubCompiler::HandlerFrontendHeader(
     Handle<HeapType> type,
     Register object_reg,
     Handle<JSObject> holder,
@@ skipping 249 matching lines @@
     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.
-  if (object->GetPrototype()->IsJSObject()) {
+  if (SAFE_GET_PROTOTYPE_FAST(*object)->IsJSObject()) {
     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.
       holder = object;
-      do {
-        holder = Handle<JSObject>(JSObject::cast(holder->GetPrototype()));
-      } while (holder->GetPrototype()->IsJSObject());
+      for (PrototypeIterator<STORE_AS_POINTER, MAP_BASED_WALK,
+                             END_AT_NULL_VALUE> iter(*holder);
+           !iter.IsAtEnd(); iter.Advance()) {
+        SLOW_ASSERT(iter.GetCurrent()->IsJSObject());
+        holder = Handle<JSObject>(JSObject::cast(iter.GetCurrent()));
+      }
     }
 
     Register holder_reg = HandlerFrontendHeader(
         IC::CurrentTypeOf(object, isolate()), 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);
@@ skipping 425 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal