Revert r11665, r11666 and r11667 due to slowness.

src/objects.cc

 // 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 5070 matching lines @@
 
 // An iterator over all map transitions in an descriptor array, reusing the map
 // field of the contens array while it is running.
 class IntrusiveMapTransitionIterator {
  public:
   explicit IntrusiveMapTransitionIterator(DescriptorArray* descriptor_array)
       : descriptor_array_(descriptor_array) { }
 
   void Start() {
     ASSERT(!IsIterating());
-    if (HasDescriptors()) *DescriptorArrayHeader() = Smi::FromInt(0);
+    if (HasContentArray()) *ContentHeader() = Smi::FromInt(0);
   }
 
   bool IsIterating() {
-    return HasDescriptors() && (*DescriptorArrayHeader())->IsSmi();
+    return HasContentArray() && (*ContentHeader())->IsSmi();
   }
 
   Map* Next() {
     ASSERT(IsIterating());
-    // Attention, tricky index manipulation ahead: Two consecutive indices are
-    // assigned to each descriptor. Most descriptors directly advance to the
-    // next descriptor by adding 2 to the index. The exceptions are the
-    // CALLBACKS entries: An even index means we look at its getter, and an odd
-    // index means we look at its setter.
-    int raw_index = Smi::cast(*DescriptorArrayHeader())->value();
-    int index = raw_index / 2;
-    while (index < descriptor_array_->number_of_descriptors()) {
-      PropertyDetails details(RawGetDetails(index));
+    FixedArray* contents = ContentArray();
+    // Attention, tricky index manipulation ahead: Every entry in the contents
+    // array consists of a value/details pair, so the index is typically even.
+    // An exception is made for CALLBACKS entries: An even index means we look
+    // at its getter, and an odd index means we look at its setter.
+    int index = Smi::cast(*ContentHeader())->value();
+    while (index < contents->length()) {
+      PropertyDetails details(Smi::cast(contents->get(index | 1)));
       switch (details.type()) {
         case MAP_TRANSITION:
         case CONSTANT_TRANSITION:
         case ELEMENTS_TRANSITION:
           // We definitely have a map transition.
-          *DescriptorArrayHeader() = Smi::FromInt(raw_index + 2);
-          return static_cast<Map*>(RawGetValue(index));
+          *ContentHeader() = Smi::FromInt(index + 2);
+          return static_cast<Map*>(contents->get(index));
         case CALLBACKS: {
           // We might have a map transition in a getter or in a setter.
           AccessorPair* accessors =
-              static_cast<AccessorPair*>(RawGetValue(index));
-          Object* accessor = ((raw_index & 1) == 0)
-              ? accessors->getter()
-              : accessors->setter();
+              static_cast<AccessorPair*>(contents->get(index & ~1));
+          Object* accessor =
+              ((index & 1) == 0) ? accessors->getter() : accessors->setter();
+          index++;
           if (accessor->IsMap()) {
-            *DescriptorArrayHeader() = Smi::FromInt(raw_index + 1);
+            *ContentHeader() = Smi::FromInt(index);
             return static_cast<Map*>(accessor);
           }
           break;
         }
         case NORMAL:
         case FIELD:
         case CONSTANT_FUNCTION:
         case HANDLER:
         case INTERCEPTOR:
         case NULL_DESCRIPTOR:
           // We definitely have no map transition.
-          raw_index += 2;
-          ++index;
+          index += 2;
           break;
       }
     }
-    *DescriptorArrayHeader() = descriptor_array_->GetHeap()->fixed_array_map();
+    *ContentHeader() = descriptor_array_->GetHeap()->fixed_array_map();
     return NULL;
   }
 
  private:
-  bool HasDescriptors() {
-    return descriptor_array_-> length() > DescriptorArray::kFirstIndex;
+  bool HasContentArray() {
+    return descriptor_array_-> length() > DescriptorArray::kContentArrayIndex;
   }
 
-  Object** DescriptorArrayHeader() {
-    return HeapObject::RawField(descriptor_array_, DescriptorArray::kMapOffset);
+  FixedArray* ContentArray() {
+    Object* array = descriptor_array_->get(DescriptorArray::kContentArrayIndex);
+    return static_cast<FixedArray*>(array);
   }
 
-  FixedArray* RawGetContentArray() {
-      Object* array =
-          descriptor_array_->get(DescriptorArray::kContentArrayIndex);
-      return static_cast<FixedArray*>(array);
+  Object** ContentHeader() {
+    return HeapObject::RawField(ContentArray(), DescriptorArray::kMapOffset);
   }
 
-  Object* RawGetValue(int descriptor_number) {
-    return RawGetContentArray()->get(
-        DescriptorArray::ToValueIndex(descriptor_number));
-  }
-
-  PropertyDetails RawGetDetails(int descriptor_number) {
-    Object* details = RawGetContentArray()->get(
-        DescriptorArray::ToDetailsIndex(descriptor_number));
-    return PropertyDetails(Smi::cast(details));
-  }
-
-
   DescriptorArray* descriptor_array_;
 };
 
 
 // An iterator over all prototype transitions, reusing the map field of the
 // underlying array while it is running.
 class IntrusivePrototypeTransitionIterator {
  public:
   explicit IntrusivePrototypeTransitionIterator(HeapObject* proto_trans)
       : proto_trans_(proto_trans) { }
@@ skipping 78 matching lines @@
   // this map's map!
   void SetParent(TraversableMap* parent) { set_map_no_write_barrier(parent); }
 
   // Reset the current map's map, returning the parent previously stored in it.
   TraversableMap* GetAndResetParent() {
     TraversableMap* old_parent = static_cast<TraversableMap*>(map());
     set_map_no_write_barrier(GetHeap()->meta_map());
     return old_parent;
   }
 
-  // Can either be Smi (no instance descriptors), or a descriptor array with the
-  // header overwritten as a Smi (thus iterating).
-  DescriptorArray* MutatedInstanceDescriptors() {
-    Object* object =
-        *HeapObject::RawField(this, kInstanceDescriptorsOrBitField3Offset);
-    if (object->IsSmi()) {
-      return GetHeap()->empty_descriptor_array();
-    } else {
-      DescriptorArray* descriptor_array =
-          static_cast<DescriptorArray*>(object);
-      ASSERT((*HeapObject::RawField(descriptor_array,
-                                    DescriptorArray::kMapOffset))->IsSmi());
-      return descriptor_array;
-    }
-  }
-
   // Start iterating over this map's children, possibly destroying a FixedArray
   // map (see explanation above).
   void ChildIteratorStart() {
     IntrusiveMapTransitionIterator(instance_descriptors()).Start();
     IntrusivePrototypeTransitionIterator(
         unchecked_prototype_transitions()).Start();
   }
 
   // If we have an unvisited child map, return that one and advance. If we have
   // none, return NULL and reset any destroyed FixedArray maps.
   TraversableMap* ChildIteratorNext() {
+    IntrusiveMapTransitionIterator descriptor_iterator(instance_descriptors());
+    if (descriptor_iterator.IsIterating()) {
+      Map* next = descriptor_iterator.Next();
+      if (next != NULL) return static_cast<TraversableMap*>(next);
+    }
     IntrusivePrototypeTransitionIterator
         proto_iterator(unchecked_prototype_transitions());
     if (proto_iterator.IsIterating()) {
       Map* next = proto_iterator.Next();
       if (next != NULL) return static_cast<TraversableMap*>(next);
     }
-    IntrusiveMapTransitionIterator
-        descriptor_iterator(MutatedInstanceDescriptors());
-    if (descriptor_iterator.IsIterating()) {
-      Map* next = descriptor_iterator.Next();
-      if (next != NULL) return static_cast<TraversableMap*>(next);
-    }
     return NULL;
   }
 };
 
 
 // Traverse the transition tree in postorder without using the C++ stack by
 // doing pointer reversal.
 void Map::TraverseTransitionTree(TraverseCallback callback, void* data) {
   TraversableMap* current = static_cast<TraversableMap*>(this);
   current->ChildIteratorStart();
@@ skipping 7908 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal