Get rid of special property_encoding flag on the LookupIterator

src/lookup.cc

 // Copyright 2014 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/bootstrapper.h"
 #include "src/deoptimizer.h"
 #include "src/lookup.h"
 #include "src/lookup-inl.h"
@@ skipping 76 matching lines @@
 void LookupIterator::ReloadPropertyInformation() {
   state_ = BEFORE_PROPERTY;
   state_ = LookupInHolder(*holder_map_, *maybe_holder_.ToHandleChecked());
   DCHECK(IsFound() || holder_map_->is_dictionary_map());
 }
 
 
 void LookupIterator::PrepareForDataProperty(Handle<Object> value) {
   DCHECK(state_ == DATA || state_ == ACCESSOR);
   DCHECK(HolderIsReceiverOrHiddenPrototype());
-  if (property_encoding_ == DICTIONARY) return;
+  if (holder_map_->is_dictionary_map()) return;
   holder_map_ =
       Map::PrepareForDataProperty(holder_map_, descriptor_number(), value);
   JSObject::MigrateToMap(GetHolder<JSObject>(), holder_map_);
   ReloadPropertyInformation();
 }
 
 
 void LookupIterator::ReconfigureDataProperty(Handle<Object> value,
                                              PropertyAttributes attributes) {
   DCHECK(state_ == DATA || state_ == ACCESSOR);
   DCHECK(HolderIsReceiverOrHiddenPrototype());
   Handle<JSObject> holder = GetHolder<JSObject>();
-  if (property_encoding_ != DICTIONARY) {
+  if (holder_map_->is_dictionary_map()) {
+    PropertyDetails details(attributes, NORMAL, 0);
+    JSObject::SetNormalizedProperty(holder, name(), value, details);
+  } else {
     holder_map_ = Map::ReconfigureDataProperty(holder_map_, descriptor_number(),
                                                attributes);
     JSObject::MigrateToMap(holder, holder_map_);
   }
 
-  if (holder_map_->is_dictionary_map()) {
-    PropertyDetails details(attributes, NORMAL, 0);
-    JSObject::SetNormalizedProperty(holder, name(), value, details);
-  }
-
   ReloadPropertyInformation();
 }
 
 
 void LookupIterator::PrepareTransitionToDataProperty(
     Handle<Object> value, PropertyAttributes attributes,
     Object::StoreFromKeyed store_mode) {
   if (state_ == TRANSITION) return;
   DCHECK(state_ != LookupIterator::ACCESSOR ||
          GetAccessors()->IsDeclaredAccessorInfo());
@@ skipping 94 matching lines @@
     DCHECK(!current->IsJSProxy());
     iter.Advance();
   } while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN));
   return false;
 }
 
 
 Handle<Object> LookupIterator::FetchValue() const {
   Object* result = NULL;
   Handle<JSObject> holder = GetHolder<JSObject>();
-  switch (property_encoding_) {
-    case DICTIONARY:
-      result = holder->property_dictionary()->ValueAt(number_);
-      if (holder->IsGlobalObject()) {
-        result = PropertyCell::cast(result)->value();
-      }
-      break;
-    case DESCRIPTOR:
-      if (property_details_.type() == v8::internal::FIELD) {
-        FieldIndex field_index =
-            FieldIndex::ForDescriptor(*holder_map_, number_);
-        return JSObject::FastPropertyAt(
-            holder, property_details_.representation(), field_index);
-      }
-      result = holder_map_->instance_descriptors()->GetValue(number_);
+  if (holder_map_->is_dictionary_map()) {
+    result = holder->property_dictionary()->ValueAt(number_);
+    if (holder_map_->IsGlobalObjectMap()) {
+      result = PropertyCell::cast(result)->value();
+    }
+  } else if (property_details_.type() == v8::internal::FIELD) {
+    FieldIndex field_index = FieldIndex::ForDescriptor(*holder_map_, number_);
+    return JSObject::FastPropertyAt(holder, property_details_.representation(),
+                                    field_index);
+  } else {
+    result = holder_map_->instance_descriptors()->GetValue(number_);
   }
   return handle(result, isolate_);
 }
 
 
 int LookupIterator::GetConstantIndex() const {
   DCHECK(has_property_);
-  DCHECK_EQ(DESCRIPTOR, property_encoding_);
+  DCHECK(!holder_map_->is_dictionary_map());
   DCHECK_EQ(v8::internal::CONSTANT, property_details_.type());
   return descriptor_number();
 }
 
 
 FieldIndex LookupIterator::GetFieldIndex() const {
   DCHECK(has_property_);
-  DCHECK_EQ(DESCRIPTOR, property_encoding_);
+  DCHECK(!holder_map_->is_dictionary_map());
   DCHECK_EQ(v8::internal::FIELD, property_details_.type());
   int index =
-      holder_map()->instance_descriptors()->GetFieldIndex(descriptor_number());
+      holder_map_->instance_descriptors()->GetFieldIndex(descriptor_number());
   bool is_double = representation().IsDouble();
-  return FieldIndex::ForPropertyIndex(*holder_map(), index, is_double);
+  return FieldIndex::ForPropertyIndex(*holder_map_, index, is_double);
 }
 
 
 Handle<HeapType> LookupIterator::GetFieldType() const {
   DCHECK(has_property_);
-  DCHECK_EQ(DESCRIPTOR, property_encoding_);
+  DCHECK(!holder_map_->is_dictionary_map());
   DCHECK_EQ(v8::internal::FIELD, property_details_.type());
   return handle(
-      holder_map()->instance_descriptors()->GetFieldType(descriptor_number()),
+      holder_map_->instance_descriptors()->GetFieldType(descriptor_number()),
       isolate_);
 }
 
 
 Handle<PropertyCell> LookupIterator::GetPropertyCell() const {
   Handle<JSObject> holder = GetHolder<JSObject>();
   Handle<GlobalObject> global = Handle<GlobalObject>::cast(holder);
   Object* value = global->property_dictionary()->ValueAt(dictionary_entry());
   return Handle<PropertyCell>(PropertyCell::cast(value));
 }
 
 
 Handle<Object> LookupIterator::GetAccessors() const {
   DCHECK_EQ(ACCESSOR, state_);
   return FetchValue();
 }
 
 
 Handle<Object> LookupIterator::GetDataValue() const {
   DCHECK_EQ(DATA, state_);
   Handle<Object> value = FetchValue();
   return value;
 }
 
 
 void LookupIterator::WriteDataValue(Handle<Object> value) {
   DCHECK(is_guaranteed_to_have_holder());
   DCHECK_EQ(DATA, state_);
   Handle<JSObject> holder = GetHolder<JSObject>();
-  if (property_encoding_ == DICTIONARY) {
+  if (holder_map_->is_dictionary_map()) {
     NameDictionary* property_dictionary = holder->property_dictionary();
     if (holder->IsGlobalObject()) {
       Handle<PropertyCell> cell(
           PropertyCell::cast(property_dictionary->ValueAt(dictionary_entry())));
       PropertyCell::SetValueInferType(cell, value);
     } else {
       property_dictionary->ValueAtPut(dictionary_entry(), *value);
     }
   } else if (property_details_.type() == v8::internal::FIELD) {
     holder->WriteToField(descriptor_number(), *value);
   } else {
     DCHECK_EQ(v8::internal::CONSTANT, property_details_.type());
   }
 }
 
 
 void LookupIterator::InternalizeName() {
   if (name_->IsUniqueName()) return;
   name_ = factory()->InternalizeString(Handle<String>::cast(name_));
 }
 } }  // namespace v8::internal