Moving prototype transitions into the header of the transition array.

src/objects.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 4789 matching lines @@
   DECL_ACCESSORS(code_cache, Object)
 
   // [back pointer]: points back to the parent map from which a transition
   // leads to this map. The field overlaps with prototype transitions and the
   // back pointer will be moved into the prototype transitions array if
   // required.
   inline Object* GetBackPointer();
   inline void SetBackPointer(Object* value,
                              WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
+  inline void init_back_pointer(Object* undefined);

[Michael Starzinger, 2012/07/06 13:53:18]

Lets make that a camel-case method (i.e. InitializeBackPointer), since it will
soon become more complex. Also drop the empty newline above.

[Toon Verwaest, 2012/07/09 12:45:27]

As discussed offline, will leave as is. Not complex since only used while
bootstrapping.

On 2012/07/06 13:53:18, Michael Starzinger wrote:

+
   // [prototype transitions]: cache of prototype transitions.
   // Prototype transition is a transition that happens
   // when we change object's prototype to a new one.
   // Cache format:
   //    0: finger - index of the first free cell in the cache
   //    1: back pointer that overlaps with prototype transitions field.
   //    2 + 2 * i: prototype
   //    3 + 2 * i: target map
-  DECL_ACCESSORS(prototype_transitions, FixedArray)
+  inline FixedArray* prototype_transitions();
+  MUST_USE_RESULT inline MaybeObject* set_prototype_transitions(
+      FixedArray* prototype_transitions);
+  inline bool HasPrototypeTransitions();
 
-  inline void init_prototype_transitions(Object* undefined);
   inline HeapObject* unchecked_prototype_transitions();
+  inline TransitionArray* unchecked_transition_array();
 
-  static const int kProtoTransitionHeaderSize = 2;
+  static const int kProtoTransitionHeaderSize = 1;
   static const int kProtoTransitionNumberOfEntriesOffset = 0;
-  static const int kProtoTransitionBackPointerOffset = 1;
   static const int kProtoTransitionElementsPerEntry = 2;
   static const int kProtoTransitionPrototypeOffset = 0;
   static const int kProtoTransitionMapOffset = 1;
 
   inline int NumberOfProtoTransitions() {
     FixedArray* cache = prototype_transitions();
     if (cache->length() == 0) return 0;
     return
         Smi::cast(cache->get(kProtoTransitionNumberOfEntriesOffset))->value();
   }
@@ skipping 152 matching lines @@
   // through an extra indirection.
   // TODO(1399): It should be possible to make room for bit_field3 in the map
   // without overloading the instance descriptors field, but the map is
   // currently perfectly aligned to 32 bytes and extending it at all would
   // double its size.  After the increment GC work lands, this size restriction
   // could be loosened and bit_field3 moved directly back in the map.
   static const int kInstanceDescriptorsOrBitField3Offset =
       kConstructorOffset + kPointerSize;
   static const int kCodeCacheOffset =
       kInstanceDescriptorsOrBitField3Offset + kPointerSize;
-  static const int kPrototypeTransitionsOrBackPointerOffset =
+  static const int kBackPointerOffset =

[Michael Starzinger, 2012/07/06 13:53:18]

This should fit in one line now?

[Toon Verwaest, 2012/07/09 12:45:27]

Done.

       kCodeCacheOffset + kPointerSize;
   static const int kPadStart =

[Michael Starzinger, 2012/07/06 13:53:18]

Likewise.

[Toon Verwaest, 2012/07/09 12:45:27]

Done.

-      kPrototypeTransitionsOrBackPointerOffset + kPointerSize;
+      kBackPointerOffset + kPointerSize;
   static const int kSize = MAP_POINTER_ALIGN(kPadStart);
 
   // Layout of pointer fields. Heap iteration code relies on them
   // being continuously allocated.
   static const int kPointerFieldsBeginOffset = Map::kPrototypeOffset;
-  static const int kPointerFieldsEndOffset =
-      kPrototypeTransitionsOrBackPointerOffset + kPointerSize;
+  static const int kPointerFieldsEndOffset = kBackPointerOffset + kPointerSize;
 
   // Byte offsets within kInstanceSizesOffset.
   static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
   static const int kInObjectPropertiesByte = 1;
   static const int kInObjectPropertiesOffset =
       kInstanceSizesOffset + kInObjectPropertiesByte;
   static const int kPreAllocatedPropertyFieldsByte = 2;
   static const int kPreAllocatedPropertyFieldsOffset =
       kInstanceSizesOffset + kPreAllocatedPropertyFieldsByte;
   static const int kVisitorIdByte = 3;
@@ skipping 3805 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_