Swap bitfield3 and backpointer.

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 1878 matching lines @@
 bool DescriptorArray::MayContainTransitions() {
   return !IsEmpty();
 }
 
 
 bool DescriptorArray::HasTransitionArray() {
   return MayContainTransitions() && !get(kTransitionsIndex)->IsSmi();
 }
 
 
-int DescriptorArray::bit_field3_storage() {
-  Object* storage = READ_FIELD(this, kBitField3StorageOffset);
-  return Smi::cast(storage)->value();
-}
-
-void DescriptorArray::set_bit_field3_storage(int value) {
-  ASSERT(length() > kBitField3StorageIndex);
-  WRITE_FIELD(this, kBitField3StorageOffset, Smi::FromInt(value));
+Object* DescriptorArray::back_pointer_storage() {
+  return READ_FIELD(this, kBackPointerStorageOffset);
 }
 
 
+void DescriptorArray::set_back_pointer_storage(Object* value,
+                                               WriteBarrierMode mode) {
+  ASSERT(length() > kBackPointerStorageIndex);
+  Heap* heap = GetHeap();
+  WRITE_FIELD(this, kBackPointerStorageOffset, value);
+  CONDITIONAL_WRITE_BARRIER(heap, this, kBackPointerStorageOffset, value, mode);
+}
+
+
 void DescriptorArray::NoIncrementalWriteBarrierSwap(FixedArray* array,
                                                     int first,
                                                     int second) {
   Object* tmp = array->get(first);
   NoIncrementalWriteBarrierSet(array, first, array->get(second));
   NoIncrementalWriteBarrierSet(array, second, tmp);
 }
 
 
 // Perform a binary search in a fixed array. Low and high are entry indices. If
@@ skipping 1475 matching lines @@
 
 
 void Map::set_prototype(Object* value, WriteBarrierMode mode) {
   ASSERT(value->IsNull() || value->IsJSReceiver());
   WRITE_FIELD(this, kPrototypeOffset, value);
   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kPrototypeOffset, value, mode);
 }
 
 
 DescriptorArray* Map::instance_descriptors() {
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBitField3Offset);
-  if (object->IsSmi()) {
+  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
+  if (!object->IsDescriptorArray()) {
+    ASSERT(object->IsMap() || object->IsUndefined());
     return GetHeap()->empty_descriptor_array();
   } else {
     return DescriptorArray::cast(object);
   }
 }
 
 
-void Map::init_instance_descriptors() {
-  WRITE_FIELD(this, kInstanceDescriptorsOrBitField3Offset, Smi::FromInt(0));
-}
-
-
-void Map::clear_instance_descriptors() {
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBitField3Offset);
-  if (!object->IsSmi()) {
-    WRITE_FIELD(
-        this,
-        kInstanceDescriptorsOrBitField3Offset,
-        Smi::FromInt(DescriptorArray::cast(object)->bit_field3_storage()));
-  }
-}
-
-
 void Map::set_instance_descriptors(DescriptorArray* value,
                                    WriteBarrierMode mode) {
-  Object* object = READ_FIELD(this,
-                              kInstanceDescriptorsOrBitField3Offset);
+  ASSERT(!value->IsFailure());

[Jakob Kummerow, 2012/07/10 12:26:25]

Can this happen?

[Toon Verwaest, 2012/07/10 13:28:28]

Removed.

On 2012/07/10 12:26:25, Jakob wrote:

+  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);

[Jakob Kummerow, 2012/07/10 12:26:25]

Looks like you can move this into the "else" block below.

[Toon Verwaest, 2012/07/10 13:28:28]

Done.

   Heap* heap = GetHeap();
   if (value == heap->empty_descriptor_array()) {
-    clear_instance_descriptors();
+    ClearDescriptorArray(heap, mode);
     return;
   } else {
-    if (object->IsSmi()) {
-      value->set_bit_field3_storage(Smi::cast(object)->value());
+    if (object->IsDescriptorArray()) {
+      value->set_back_pointer_storage(
+          DescriptorArray::cast(object)->back_pointer_storage());
     } else {
-      value->set_bit_field3_storage(
-          DescriptorArray::cast(object)->bit_field3_storage());
+      ASSERT(object->IsMap() || object->IsUndefined());
+      value->set_back_pointer_storage(object);
     }
   }
   ASSERT(!is_shared());
-  WRITE_FIELD(this, kInstanceDescriptorsOrBitField3Offset, value);
+  WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, value);
   CONDITIONAL_WRITE_BARRIER(
-      heap, this, kInstanceDescriptorsOrBitField3Offset, value, mode);
+      heap, this, kInstanceDescriptorsOrBackPointerOffset, value, mode);
 }
 
 
 int Map::bit_field3() {

[Jakob Kummerow, 2012/07/10 12:26:25]

SMI_ACCESSORS(Map, bit_field3, kBitField3Offset)
should take care of both this and the setter below.

[Toon Verwaest, 2012/07/10 13:28:28]

Done.

-  Object* object = READ_FIELD(this,
-                              kInstanceDescriptorsOrBitField3Offset);
-  if (object->IsSmi()) {
-    return Smi::cast(object)->value();
+  return Smi::cast(READ_FIELD(this, kBitField3Offset))->value();
+}
+
+
+void Map::ClearDescriptorArray(Heap* heap, WriteBarrierMode mode) {
+  Object* back_pointer = GetBackPointer();
+#ifdef DEBUG
+  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
+  if (object->IsDescriptorArray()) {
+    ZapTransitions();
   } else {
-    return DescriptorArray::cast(object)->bit_field3_storage();
+    ASSERT(object->IsMap() || object->IsUndefined());
+  }
+#endif
+  WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, back_pointer);
+  CONDITIONAL_WRITE_BARRIER(
+      heap, this, kInstanceDescriptorsOrBackPointerOffset, back_pointer, mode);
+}
+
+
+void Map::set_bit_field3(int value) {
+  WRITE_FIELD(this, kBitField3Offset, Smi::FromInt(value));
+}
+
+
+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;
   }
 }
 
 
-void Map::ClearDescriptorArray() {
-  int bitfield3 = bit_field3();
-#ifdef DEBUG
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBitField3Offset);
-  if (!object->IsSmi()) {
-    ZapTransitions();
-  }
-#endif
-  WRITE_FIELD(this,
-              kInstanceDescriptorsOrBitField3Offset,
-              Smi::FromInt(bitfield3));
-}
-
-
-void Map::set_bit_field3(int value) {
-  ASSERT(Smi::IsValid(value));
-  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBitField3Offset);
-  if (object->IsSmi()) {
-    WRITE_FIELD(this,
-                kInstanceDescriptorsOrBitField3Offset,
-                Smi::FromInt(value));
-  } else {
-    DescriptorArray::cast(object)->set_bit_field3_storage(value);
-  }
-}
-
-
-Object* Map::GetBackPointer() {
-  return READ_FIELD(this, kBackPointerOffset);
-}
-
-
 bool Map::HasElementsTransition() {
   return HasTransitionArray() && transitions()->HasElementsTransition();
 }
 
 
 bool Map::HasTransitionArray() {
   return instance_descriptors()->HasTransitionArray();
 }
 
 
 Map* Map::elements_transition_map() {
   return transitions()->elements_transition();
 }
 
 
 MaybeObject* Map::AddTransition(String* key, Object* value) {
   if (HasTransitionArray()) return transitions()->CopyInsert(key, value);
   return TransitionArray::NewWith(key, value);
 }
 
 
-// If the map does not have a descriptor array, install a new empty
-// descriptor array that has room for a transition array.
+// If the map is using the empty descriptor array, install a new empty
+// descriptor array that will contain an element transition.

[Jakob Kummerow, 2012/07/10 12:26:25]

nit: s/element/elements/

[Toon Verwaest, 2012/07/10 13:28:28]

Done.

 static MaybeObject* AllowTransitions(Map* map) {
   if (map->instance_descriptors()->MayContainTransitions()) return map;
   DescriptorArray* descriptors;
   MaybeObject* maybe_descriptors =
       DescriptorArray::Allocate(0, DescriptorArray::CANNOT_BE_SHARED);
   if (!maybe_descriptors->To(&descriptors)) return maybe_descriptors;
   map->set_instance_descriptors(descriptors);
   return descriptors;
 }
 
@@ skipping 48 matching lines @@
 bool Map::HasPrototypeTransitions() {
   return HasTransitionArray() && transitions()->HasPrototypeTransitions();
 }
 
 
 TransitionArray* Map::transitions() {
   return instance_descriptors()->transitions();
 }
 
 
-void Map::ClearTransitions() {
+void Map::ClearTransitions(Heap* heap, WriteBarrierMode mode) {
 #ifdef DEBUG
   ZapTransitions();
 #endif
   DescriptorArray* descriptors = instance_descriptors();
   if (descriptors->number_of_descriptors() == 0) {
-    ClearDescriptorArray();
+    ClearDescriptorArray(heap, mode);
   } else {
     descriptors->ClearTransitions();
   }
 }
 
 
 MaybeObject* Map::set_transitions(TransitionArray* transitions_array) {
   MaybeObject* allow_transitions = AllowTransitions(this);
   if (allow_transitions->IsFailure()) return allow_transitions;
 #ifdef DEBUG
   if (HasTransitionArray()) {
     ASSERT(transitions() != transitions_array);
     ZapTransitions();
   }
 #endif
   instance_descriptors()->set_transitions(transitions_array);
   return this;
 }
 
 
 void Map::init_back_pointer(Object* undefined) {
   ASSERT(undefined->IsUndefined());
-  WRITE_FIELD(this, kBackPointerOffset, undefined);
+  WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, undefined);
 }
 
 
 void Map::SetBackPointer(Object* value, WriteBarrierMode mode) {
-  Heap* heap = GetHeap();
   ASSERT(instance_type() >= FIRST_JS_RECEIVER_TYPE);
   ASSERT((value->IsUndefined() && GetBackPointer()->IsMap()) ||
          (value->IsMap() && GetBackPointer()->IsUndefined()));
-  WRITE_FIELD(this, kBackPointerOffset, value);
-  CONDITIONAL_WRITE_BARRIER(heap, this, kBackPointerOffset, value, mode);
+  Object* object = READ_FIELD(this, kInstanceDescriptorsOrBackPointerOffset);
+  if (object->IsMap()) {
+    ASSERT(!value->IsFailure());

[Jakob Kummerow, 2012/07/10 12:26:25]

Can this happen?

[Toon Verwaest, 2012/07/10 13:28:28]

Removed.

On 2012/07/10 12:26:25, Jakob wrote:

+    WRITE_FIELD(this, kInstanceDescriptorsOrBackPointerOffset, value);
+    CONDITIONAL_WRITE_BARRIER(
+        GetHeap(), this, kInstanceDescriptorsOrBackPointerOffset, value, mode);
+  } else {

[Jakob Kummerow, 2012/07/10 12:26:25]

What if (object->IsUndefined()) ?

[Toon Verwaest, 2012/07/10 13:28:28]

Then we just overwrite it, since it's the default back-pointer value.

On 2012/07/10 12:26:25, Jakob wrote:

+    DescriptorArray::cast(object)->set_back_pointer_storage(value);
+  }
 }
 
 
 // Can either be Smi (no transitions), normal transition array, or a transition
 // array with the header overwritten as a Smi (thus iterating).
 TransitionArray* Map::unchecked_transition_array() {
   ASSERT(HasTransitionArray());
   Object* object = *HeapObject::RawField(instance_descriptors(),
                                          DescriptorArray::kTransitionsOffset);
   ASSERT(!object->IsSmi());
@@ skipping 1647 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_