Allocate as many object-literal properties as possible inobject....

src/objects.h

 // Copyright 2006-2008 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 148 matching lines @@
   class TypeField:       public BitField<PropertyType,       0, 3> {};
   class AttributesField: public BitField<PropertyAttributes, 3, 3> {};
   class IndexField:      public BitField<uint32_t,           6, 32-6> {};
 
   static const int kInitialIndex = 1;
 
  private:
   uint32_t value_;
 };
 
+
 // Setter that skips the write barrier if mode is SKIP_WRITE_BARRIER.
 enum WriteBarrierMode { SKIP_WRITE_BARRIER, UPDATE_WRITE_BARRIER };
 
+
+// PropertyNormalizationMode is used to specify wheter or not to
+// keep inobject properties when normalizing properties of a
+// JSObject.
+enum PropertyNormalizationMode {
+  CLEAR_INOBJECT_PROPERTIES,
+  KEEP_INOBJECT_PROPERTIES
+};
+
+
 // All Maps have a field instance_type containing a InstanceType.
 // It describes the type of the instances.
 //
 // As an example, a JavaScript object is a heap object and its map
 // instance_type is JS_OBJECT_TYPE.
 //
 // The names of the string instance types are intended to systematically
 // mirror their encoding in the instance_type field of the map.  The length
 // (SHORT, MEDIUM, or LONG) is always mentioned.  The default encoding is
 // considered TWO_BYTE.  It is not mentioned in the name.  ASCII encoding is
@@ skipping 371 matching lines @@
 
   NOT_EQUAL = GREATER
 };
 
 
 #define DECL_BOOLEAN_ACCESSORS(name)   \
   inline bool name();                  \
   inline void set_##name(bool value);  \
 
 
-#define DECL_ACCESSORS(name, type)    \
-  inline type* name();                \
-  inline void set_##name(type* value, \
+#define DECL_ACCESSORS(name, type)                                      \
+  inline type* name();                                                  \
+  inline void set_##name(type* value,                                   \
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \
 
 
 class StringStream;
 class ObjectVisitor;
 
 struct ValueInfo : public Malloced {
   ValueInfo() : type(FIRST_TYPE), ptr(NULL), str(NULL), number(0) { }
   InstanceType type;
   Object* ptr;
@@ skipping 774 matching lines @@
                           Object* value,
                           PropertyAttributes attributes);
 
   // Add a property to an object.
   Object* AddProperty(String* name,
                       Object* value,
                       PropertyAttributes attributes);
 
   // Convert the object to use the canonical dictionary
   // representation.
-  Object* NormalizeProperties();
+  Object* NormalizeProperties(PropertyNormalizationMode mode);
   Object* NormalizeElements();
 
   // Transform slow named properties to fast variants.
   // Returns failure if allocation failed.
   Object* TransformToFastProperties(int unused_property_fields);
 
   // Access fast-case object properties at index.
   inline Object* FastPropertyAt(int index);
   inline Object* FastPropertyAtPut(int index, Object* value);
 
@@ skipping 915 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
 };
 
 
 // All heap objects have a Map that describes their structure.
 //  A Map contains information about:
 //  - Size information about the object
 //  - How to iterate over an object (for garbage collection)
 class Map: public HeapObject {
  public:
-  // instance size.
+  // Instance size.
   inline int instance_size();
   inline void set_instance_size(int value);
 
   // Count of properties allocated in the object.
   inline int inobject_properties();
   inline void set_inobject_properties(int value);
 
-  // instance type.
+  // Instance type.
   inline InstanceType instance_type();
   inline void set_instance_type(InstanceType value);
 
-  // tells how many unused property fields are available in the instance.
-  // (only used for JSObject in fast mode).
+  // Tells how many unused property fields are available in the
+  // instance (only used for JSObject in fast mode).
   inline int unused_property_fields();
   inline void set_unused_property_fields(int value);
 
-  // bit field.
+  // Bit field.
   inline byte bit_field();
   inline void set_bit_field(byte value);
 
   // 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();
@@ skipping 132 matching lines @@
   static const int kInstanceDescriptorsOffset =
       kConstructorOffset + kPointerSize;
   static const int kCodeCacheOffset = kInstanceDescriptorsOffset + kPointerSize;
   static const int kSize = kCodeCacheOffset + kIntSize;
 
   // Byte offsets within kInstanceSizesOffset.
   static const int kInstanceSizeOffset = kInstanceSizesOffset + 0;
   static const int kInObjectPropertiesOffset = kInstanceSizesOffset + 1;
   // The bytes at positions 2 and 3 are not in use at the moment.
 
-
   // Byte offsets within kInstanceAttributesOffset attributes.
   static const int kInstanceTypeOffset = kInstanceAttributesOffset + 0;
   static const int kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 1;
   static const int kBitFieldOffset = kInstanceAttributesOffset + 2;
   // The  byte at position 3 is not in use at the moment.
 
   // Bit positions for bit field.
   static const int kUnused = 0;  // To be used for marking recently used maps.
   static const int kHasNonInstancePrototype = 1;
   static const int kIsHiddenPrototype = 2;
@@ skipping 1729 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_