Flatten property_kind into state. Add UNKNOWN as a state for dict-mode receivers

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/base/bits.h"
@@ skipping 197 matching lines @@
   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:
+      case LookupIterator::UNKNOWN:
         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;
+      case LookupIterator::ACCESSOR:
+      case LookupIterator::DATA:
+        return;
     }
   }
 }
 
 
 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);
@@ skipping 28 matching lines @@
     int index = ic_holder_map->IndexInCodeCache(*name, *target());
     if (index >= 0) {
       ic_holder_map->RemoveFromCodeCache(*name, *target(), index);
     }
   }
 
   if (receiver->IsGlobalObject()) {
     Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
     LookupIterator it(global, name, LookupIterator::OWN_SKIP_INTERCEPTOR);
     if (it.state() == LookupIterator::ACCESS_CHECK) return false;
-    if (!it.IsFound() || !it.HasProperty()) return false;
+    if (!it.IsFound()) return false;
     Handle<PropertyCell> cell = it.GetPropertyCell();
     return cell->type()->IsConstant();
   }
 
   return true;
 }
 
 
 bool IC::IsNameCompatibleWithPrototypeFailure(Handle<Object> name) {
   if (target()->is_keyed_stub()) {
@@ skipping 670 matching lines @@
                                       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);
     return compiler.CompileLoadInterceptor(&it);
   }
 
   // -------------- Accessors --------------
-  DCHECK(lookup->state() == LookupIterator::PROPERTY);
-  if (lookup->property_kind() == LookupIterator::ACCESSOR) {
+  if (lookup->state() == 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);
       int object_offset;
       if (Accessors::IsJSObjectFieldAccessor<HeapType>(type, lookup->name(),
                                                        &object_offset)) {
         FieldIndex index =
             FieldIndex::ForInObjectOffset(object_offset, js_receiver->map());
         return SimpleFieldLoad(index);
@@ skipping 34 matching lines @@
         return compiler.CompileLoadCallback(lookup->name(), call_optimization);
       }
       return compiler.CompileLoadViaGetter(lookup->name(), function);
     }
     // TODO(dcarney): Handle correctly.
     DCHECK(accessors->IsDeclaredAccessorInfo());
     return slow_stub();
   }
 
   // -------------- Dictionary properties --------------
-  DCHECK(lookup->property_kind() == LookupIterator::DATA);
+  DCHECK(lookup->state() == LookupIterator::DATA);
   if (lookup->property_encoding() == LookupIterator::DICTIONARY) {
     if (kind() != Code::LOAD_IC) return slow_stub();
     if (holder->IsGlobalObject()) {
       NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                         cache_holder);
       Handle<PropertyCell> cell = lookup->GetPropertyCell();
       Handle<Code> code = compiler.CompileLoadGlobal(cell, lookup->name(),
                                                      lookup->IsConfigurable());
       // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
       CacheHolderFlag flag;
@@ skipping 170 matching lines @@
                              JSReceiver::StoreFromKeyed store_mode) {
   // Disable ICs for non-JSObjects for now.
   Handle<Object> receiver = it->GetReceiver();
   if (!receiver->IsJSObject()) return false;
   DCHECK(!Handle<JSObject>::cast(receiver)->map()->is_deprecated());
 
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
+      case LookupIterator::UNKNOWN:
         UNREACHABLE();
       case LookupIterator::JSPROXY:
         return false;
       case LookupIterator::INTERCEPTOR: {
         Handle<JSObject> holder = it->GetHolder<JSObject>();
         InterceptorInfo* info = holder->GetNamedInterceptor();
         if (it->HolderIsReceiverOrHiddenPrototype()) {
           if (!info->setter()->IsUndefined()) return true;
         } else if (!info->getter()->IsUndefined() ||
                    !info->query()->IsUndefined()) {
           return false;
         }
         break;
       }
       case LookupIterator::ACCESS_CHECK:
         if (it->GetHolder<JSObject>()->IsAccessCheckNeeded()) return false;
         break;
-      case LookupIterator::PROPERTY:
-        if (!it->HasProperty()) break;
+      case LookupIterator::ACCESSOR:
+        return !it->IsReadOnly();
+      case LookupIterator::DATA: {
         if (it->IsReadOnly()) return false;
-        if (it->property_kind() == LookupIterator::ACCESSOR) return true;
-        if (it->GetHolder<Object>().is_identical_to(receiver)) {
+        Handle<JSObject> holder = it->GetHolder<JSObject>();
+        if (receiver.is_identical_to(holder)) {
           it->PrepareForDataProperty(value);
           // The previous receiver map might just have been deprecated,
           // so reload it.
           update_receiver_type(receiver);
           return true;
         }
 
         // Receiver != holder.
+        PrototypeIterator iter(it->isolate(), receiver);
         if (receiver->IsJSGlobalProxy()) {
-          PrototypeIterator iter(it->isolate(), receiver);
           return it->GetHolder<Object>().is_identical_to(
               PrototypeIterator::GetCurrent(iter));
         }
 
         it->PrepareTransitionToDataProperty(value, NONE, store_mode);
         return it->IsCacheableTransition();
+      }
     }
   }
 
   it->PrepareTransitionToDataProperty(value, NONE, store_mode);
   return it->IsCacheableTransition();
 }
 
 
 MaybeHandle<Object> StoreIC::Store(Handle<Object> object, Handle<Name> name,
                                    Handle<Object> value,
@@ skipping 136 matching lines @@
   }
 
   // -------------- Interceptors --------------
   if (lookup->state() == LookupIterator::INTERCEPTOR) {
     DCHECK(!holder->GetNamedInterceptor()->setter()->IsUndefined());
     NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
     return compiler.CompileStoreInterceptor(lookup->name());
   }
 
   // -------------- Accessors --------------
-  DCHECK(lookup->state() == LookupIterator::PROPERTY);
-  if (lookup->property_kind() == LookupIterator::ACCESSOR) {
+  if (lookup->state() == LookupIterator::ACCESSOR) {
     if (!holder->HasFastProperties()) return slow_stub();
     Handle<Object> accessors = lookup->GetAccessors();
     if (accessors->IsExecutableAccessorInfo()) {
       Handle<ExecutableAccessorInfo> info =
           Handle<ExecutableAccessorInfo>::cast(accessors);
       if (v8::ToCData<Address>(info->setter()) == 0) return slow_stub();
       if (!ExecutableAccessorInfo::IsCompatibleReceiverType(isolate(), info,
                                                             receiver_type())) {
         return slow_stub();
       }
@@ skipping 13 matching lines @@
       }
       return compiler.CompileStoreViaSetter(receiver, lookup->name(),
                                             Handle<JSFunction>::cast(setter));
     }
     // TODO(dcarney): Handle correctly.
     DCHECK(accessors->IsDeclaredAccessorInfo());
     return slow_stub();
   }
 
   // -------------- Dictionary properties --------------
-  DCHECK(lookup->property_kind() == LookupIterator::DATA);
+  DCHECK(lookup->state() == LookupIterator::DATA);
   if (lookup->property_encoding() == LookupIterator::DICTIONARY) {
     if (holder->IsGlobalObject()) {
       Handle<PropertyCell> cell = lookup->GetPropertyCell();
       Handle<HeapType> union_type = PropertyCell::UpdatedType(cell, value);
       StoreGlobalStub stub(isolate(), union_type->IsConstant(),
                            receiver->IsJSGlobalProxy());
       Handle<Code> code = stub.GetCodeCopyFromTemplate(
           Handle<GlobalObject>::cast(holder), cell);
       // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
       HeapObject::UpdateMapCodeCache(receiver, lookup->name(), code);
@@ skipping 1733 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