Use a special EnumLength field to indicate number of valid enum cache values.

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 4626 matching lines @@
   inline byte bit_field2();
   inline void set_bit_field2(byte value);
 
   // Bit field 3.
   inline int bit_field3();
   inline void set_bit_field3(int value);
 
   class IsShared:              public BitField<bool, 0, 1> {};
   class FunctionWithPrototype: public BitField<bool, 1, 1> {};
   class LastAddedBits:         public BitField<int, 2, 11> {};
+  class EnumLengthBits:        public BitField<int, 13, 11> {};
 
   // Tells whether the object in the prototype property will be used
   // for instances created from this function.  If the prototype
   // property is set to a value that is not a JSObject, the prototype
   // property will not be used to create instances of the function.
   // See ECMA-262, 13.2.2.
   inline void set_non_instance_prototype(bool value);
   inline bool has_non_instance_prototype();
 
   // Tells whether function has special prototype property. If not, prototype
@@ skipping 212 matching lines @@
 
   // The size of transition arrays are limited so they do not end up in large
   // object space. Otherwise ClearNonLiveTransitions would leak memory while
   // applying in-place right trimming.
   inline bool CanHaveMoreTransitions();
 
   void SetLastAdded(int index) {
     set_bit_field3(LastAddedBits::update(bit_field3(), index));
   }
 
+  int EnumLength() {
+    return EnumLengthBits::decode(bit_field3());
+  }
+
+  void SetEnumLength(int index) {
+    set_bit_field3(EnumLengthBits::update(bit_field3(), index));
+  }
+
   int LastAdded() {

[Michael Starzinger, 2012/08/06 15:06:22]

Can we move LastAdded() up just above SetLastAdded()?

[Toon Verwaest, 2012/08/07 10:49:47]

Done.

     return LastAddedBits::decode(bit_field3());
   }
 
   int NumberOfSetDescriptors() {
     ASSERT(!instance_descriptors()->IsEmpty());
     if (LastAdded() == kNoneAdded) return 0;
     return instance_descriptors()->GetDetails(LastAdded()).index();
   }
 
   MUST_USE_RESULT MaybeObject* RawCopy(int instance_size);
@@ skipping 131 matching lines @@
 
   Map* GetPrototypeTransition(Object* prototype);
 
   MUST_USE_RESULT MaybeObject* PutPrototypeTransition(Object* prototype,
                                                       Map* map);
 
   static const int kMaxPreAllocatedPropertyFields = 255;
 
   // Constant for denoting that the LastAdded field was not yet set.
   static const int kNoneAdded = LastAddedBits::kMax;
+  static const int kInvalidEnumCache = EnumLengthBits::kMax;
 
   // Layout description.
   static const int kInstanceSizesOffset = HeapObject::kHeaderSize;
   static const int kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize;
   static const int kPrototypeOffset = kInstanceAttributesOffset + kIntSize;
   static const int kConstructorOffset = kPrototypeOffset + kPointerSize;
   // Storage for instance descriptors is overloaded to also contain additional
   // map flags when unused (bit_field3). When the map has instance descriptors,
   // the flags are transferred to the instance descriptor array and accessed
   // through an extra indirection.
@@ skipping 3838 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_