Implement loads and calls from 'super'

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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/codegen.h"
@@ skipping 191 matching lines @@
 Code* IC::GetOriginalCode() const {
   HandleScope scope(isolate());
   Handle<SharedFunctionInfo> shared(GetSharedFunctionInfo(), isolate());
   DCHECK(Debug::HasDebugInfo(shared));
   Code* original_code = Debug::GetDebugInfo(shared)->original_code();
   DCHECK(original_code->IsCode());
   return original_code;
 }
 
 
-static void LookupForRead(LookupIterator* it) {
-  for (; it->IsFound(); it->Next()) {
-    switch (it->state()) {
-      case LookupIterator::NOT_FOUND:
-      case LookupIterator::TRANSITION:
-        UNREACHABLE();
-      case LookupIterator::JSPROXY:
-        return;
-      case LookupIterator::INTERCEPTOR: {
-        // If there is a getter, return; otherwise loop to perform the lookup.
-        Handle<JSObject> holder = it->GetHolder<JSObject>();
-        if (!holder->GetNamedInterceptor()->getter()->IsUndefined()) {
-          return;
-        }
-        break;
-      }
-      case LookupIterator::ACCESS_CHECK:
-        // PropertyHandlerCompiler::CheckPrototypes() knows how to emit
-        // access checks for global proxies.
-        if (it->GetHolder<JSObject>()->IsJSGlobalProxy() &&
-            it->HasAccess(v8::ACCESS_GET)) {
-          break;
-        }
-        return;
-      case LookupIterator::PROPERTY:
-        if (it->HasProperty()) return;  // Yay!
-        break;
-    }
-  }
-}
-
-
 bool IC::TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver,
                                                 Handle<String> name) {
   if (!IsNameCompatibleWithPrototypeFailure(name)) return false;
   Handle<Map> receiver_map = TypeToMap(*receiver_type(), isolate());
   maybe_handler_ = target()->FindHandlerForMap(*receiver_map);
 
   // The current map wasn't handled yet. There's no reason to stay monomorphic,
   // *unless* we're moving from a deprecated map to its replacement, or
   // to a more general elements kind.
   // TODO(verwaest): Check if the current map is actually what the old map
@@ skipping 343 matching lines @@
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate(), result,
         Runtime::GetElementOrCharAt(isolate(), object, index), Object);
     return result;
   }
 
   bool use_ic = MigrateDeprecated(object) ? false : FLAG_use_ic;
 
   // Named lookup in the object.
   LookupIterator it(object, name);
-  LookupForRead(&it);
+  it.LookupForRead();
 
   if (it.IsFound() || !IsUndeclaredGlobal(object)) {
     // Update inline cache and stub cache.
     if (use_ic) UpdateCaches(&it);
 
     // Get the property.
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(isolate(), result, Object::GetProperty(&it),
                                Object);
     if (it.IsFound()) {
@@ skipping 345 matching lines @@
   bool receiver_is_holder = receiver.is_identical_to(holder);
   // -------------- Interceptors --------------
   if (lookup->state() == LookupIterator::INTERCEPTOR) {
     DCHECK(!holder->GetNamedInterceptor()->getter()->IsUndefined());
     NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                       cache_holder);
     // Perform a lookup behind the interceptor. Copy the LookupIterator since
     // the original iterator will be used to fetch the value.
     LookupIterator it = *lookup;
     it.Next();
-    LookupForRead(&it);
+    it.LookupForRead();
     return compiler.CompileLoadInterceptor(&it);
   }
 
   // -------------- Accessors --------------
   DCHECK(lookup->state() == LookupIterator::PROPERTY);
   if (lookup->property_kind() == LookupIterator::ACCESSOR) {
     // Use simple field loads for some well-known callback properties.
     if (receiver_is_holder) {
       DCHECK(receiver->IsJSObject());
       Handle<JSObject> js_receiver = Handle<JSObject>::cast(receiver);
@@ skipping 2216 matching lines @@
 static const Address IC_utilities[] = {
 #define ADDR(name) FUNCTION_ADDR(name),
     IC_UTIL_LIST(ADDR) NULL
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) { return IC_utilities[id]; }
 }
 }  // namespace v8::internal