Get rid of special property_encoding flag on the LookupIterator

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 880 matching lines @@
 
 Handle<Code> IC::ComputeHandler(LookupIterator* lookup, Handle<Object> value) {
   bool receiver_is_holder =
       lookup->GetReceiver().is_identical_to(lookup->GetHolder<JSObject>());
   CacheHolderFlag flag;
   Handle<Map> stub_holder_map = IC::GetHandlerCacheHolder(
       *receiver_type(), receiver_is_holder, isolate(), &flag);
 
   Handle<Code> code = PropertyHandlerCompiler::Find(
       lookup->name(), stub_holder_map, kind(), flag,
-      lookup->holder_map()->is_dictionary_map() ? Code::NORMAL : Code::FAST);
+      lookup->is_dictionary_holder() ? Code::NORMAL : Code::FAST);
   // Use the cached value if it exists, and if it is different from the
   // handler that just missed.
   if (!code.is_null()) {
     if (!maybe_handler_.is_null() &&
         !maybe_handler_.ToHandleChecked().is_identical_to(code)) {
       return code;
     }
     if (maybe_handler_.is_null()) {
       // maybe_handler_ is only populated for MONOMORPHIC and POLYMORPHIC ICs.
       // In MEGAMORPHIC case, check if the handler in the megamorphic stub
@@ skipping 114 matching lines @@
       }
       return compiler.CompileLoadViaGetter(lookup->name(), function);
     }
     // TODO(dcarney): Handle correctly.
     DCHECK(accessors->IsDeclaredAccessorInfo());
     return slow_stub();
   }
 
   // -------------- Dictionary properties --------------
   DCHECK(lookup->state() == LookupIterator::DATA);
-  if (lookup->property_encoding() == LookupIterator::DICTIONARY) {
+  if (lookup->is_dictionary_holder()) {
     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;
       Handle<Map> stub_holder_map =
           GetHandlerCacheHolder(*type, receiver_is_holder, isolate(), &flag);
       Map::UpdateCodeCache(stub_holder_map, lookup->name(), code);
       return code;
     }
     // There is only one shared stub for loading normalized
     // properties. It does not traverse the prototype chain, so the
     // property must be found in the object for the stub to be
     // applicable.
     if (!receiver_is_holder) return slow_stub();
     return isolate()->builtins()->LoadIC_Normal();
   }
 
   // -------------- Fields --------------
-  DCHECK(lookup->property_encoding() == LookupIterator::DESCRIPTOR);
   if (lookup->property_details().type() == FIELD) {
     FieldIndex field = lookup->GetFieldIndex();
     if (receiver_is_holder) {
       return SimpleFieldLoad(field);
     }
     NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                       cache_holder);
     return compiler.CompileLoadField(lookup->name(), field);
   }
 
@@ skipping 377 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->state() == LookupIterator::DATA);
-  if (lookup->property_encoding() == LookupIterator::DICTIONARY) {
+  if (lookup->is_dictionary_holder()) {
     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);
       return code;
     }
     DCHECK(holder.is_identical_to(receiver));
     return isolate()->builtins()->StoreIC_Normal();
   }
 
   // -------------- Fields --------------
-  DCHECK(lookup->property_encoding() == LookupIterator::DESCRIPTOR);
   if (lookup->property_details().type() == FIELD) {
     bool use_stub = true;
     if (lookup->representation().IsHeapObject()) {
       // Only use a generic stub if no types need to be tracked.
       Handle<HeapType> field_type = lookup->GetFieldType();
       HeapType::Iterator<Map> it = field_type->Classes();
       use_stub = it.Done();
     }
     if (use_stub) {
       StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
@@ skipping 1715 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