Moved lastadded from DescriptorArray to Map. Renamed kLastAdded to kEnumCache.

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2936 matching lines @@
   }
 }
 
 
 bool Map::has_non_instance_prototype() {
   return ((1 << kHasNonInstancePrototype) & bit_field()) != 0;
 }
 
 
 void Map::set_function_with_prototype(bool value) {
-  if (value) {
-    set_bit_field3(bit_field3() | (1 << kFunctionWithPrototype));
-  } else {
-    set_bit_field3(bit_field3() & ~(1 << kFunctionWithPrototype));
-  }
+  set_bit_field3(FunctionWithPrototype::update(bit_field3(), value));
 }
 
 
 bool Map::function_with_prototype() {
-  return ((1 << kFunctionWithPrototype) & bit_field3()) != 0;
+  return FunctionWithPrototype::decode(bit_field3());
 }
 
 
 void Map::set_is_access_check_needed(bool access_check_needed) {
   if (access_check_needed) {
     set_bit_field(bit_field() | (1 << kIsAccessCheckNeeded));
   } else {
     set_bit_field(bit_field() & ~(1 << kIsAccessCheckNeeded));
   }
 }
@@ skipping 24 matching lines @@
     set_bit_field2(bit_field2() & ~(1 << kAttachedToSharedFunctionInfo));
   }
 }
 
 bool Map::attached_to_shared_function_info() {
   return ((1 << kAttachedToSharedFunctionInfo) & bit_field2()) != 0;
 }
 
 
 void Map::set_is_shared(bool value) {
-  if (value) {
-    set_bit_field3(bit_field3() | (1 << kIsShared));
-  } else {
-    set_bit_field3(bit_field3() & ~(1 << kIsShared));
-  }
+  set_bit_field3(IsShared::update(bit_field3(), value));
 }
 
 bool Map::is_shared() {
-  return ((1 << kIsShared) & bit_field3()) != 0;
+  return IsShared::decode(bit_field3());
 }
 
 
 JSFunction* Map::unchecked_constructor() {
   return reinterpret_cast<JSFunction*>(READ_FIELD(this, kConstructorOffset));
 }
 
 
 Code::Flags Code::flags() {
   return static_cast<Flags>(READ_INT_FIELD(this, kFlagsOffset));
@@ skipping 485 matching lines @@
   // the descriptor array.
   for (int i = 0; i < len; ++i) {
     int enum_index = descriptors->GetDetails(i).index() -
                      PropertyDetails::kInitialIndex;
     ASSERT(0 <= enum_index && enum_index < len);
     ASSERT(!used_indices[enum_index]);
     used_indices[enum_index] = true;
   }
 #endif
 
+  set_instance_descriptors(descriptors);
+
   for (int i = 0; i < len; ++i) {
     if (descriptors->GetDetails(i).index() == len) {
-      descriptors->SetLastAdded(i);
+      SetLastAdded(i);
       break;
     }
   }
 
   ASSERT(len == 0 ||
-         len == descriptors->GetDetails(descriptors->LastAdded()).index());
-
-  set_instance_descriptors(descriptors);
+         len == descriptors->GetDetails(LastAdded()).index());
 }
 
 
 SMI_ACCESSORS(Map, bit_field3, kBitField3Offset)
 
 
 void Map::ClearDescriptorArray(Heap* heap, WriteBarrierMode mode) {
   Object* back_pointer = GetBackPointer();
 #ifdef DEBUG
   Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
   if (object->IsDescriptorArray()) {
     ZapTransitions();
   } else {
     ASSERT(object->IsMap() || object->IsUndefined());
   }
 #endif
   WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, back_pointer);
   CONDITIONAL_WRITE_BARRIER(
       heap, this, kInstanceDescriptorsOrBackPointerOffset, back_pointer, mode);
 }
 
 
 void Map::AppendDescriptor(Descriptor* desc,
                            const DescriptorArray::WhitenessWitness& witness) {
   DescriptorArray* descriptors = instance_descriptors();
-  int set_descriptors = descriptors->NumberOfSetDescriptors();
+  int set_descriptors = NumberOfSetDescriptors();
   int new_last_added = descriptors->Append(desc, witness, set_descriptors);
-  descriptors->SetLastAdded(new_last_added);
+  SetLastAdded(new_last_added);
 }
 
 
 Object* Map::GetBackPointer() {
   Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
   if (object->IsDescriptorArray()) {
     return DescriptorArray::cast(object)->back_pointer_storage();
   } else {
     ASSERT(object->IsMap() || object->IsUndefined());
     return object;
@@ skipping 1804 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_