Use linear backing store for hidden properties to save memory.

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 56 matching lines @@
 //             - JSBuiltinsObject
 //           - JSGlobalProxy
 //           - JSValue
 //             - JSDate
 //           - JSMessageObject
 //         - JSProxy
 //           - JSFunctionProxy
 //       - FixedArrayBase
 //         - ByteArray
 //         - FixedArray
+//           - HiddenPropertiesArray
 //           - DescriptorArray
 //           - HashTable
 //             - Dictionary
 //             - SymbolTable
 //             - CompilationCacheTable
 //             - CodeCacheHashTable
 //             - MapCache
 //           - Context
 //           - JSFunctionResultCache
 //           - ScopeInfo
@@ skipping 705 matching lines @@
   V(ExternalFloatArray)                        \
   V(ExternalDoubleArray)                       \
   V(ExternalPixelArray)                        \
   V(ByteArray)                                 \
   V(FreeSpace)                                 \
   V(JSReceiver)                                \
   V(JSObject)                                  \
   V(JSContextExtensionObject)                  \
   V(JSModule)                                  \
   V(Map)                                       \
+  V(HiddenPropertiesArray)                     \
   V(DescriptorArray)                           \
   V(TransitionArray)                           \
   V(DeoptimizationInputData)                   \
   V(DeoptimizationOutputData)                  \
   V(TypeFeedbackCells)                         \
   V(FixedArray)                                \
   V(FixedDoubleArray)                          \
   V(Context)                                   \
   V(GlobalContext)                             \
   V(ModuleContext)                             \
@@ skipping 1416 matching lines @@
       Object* getter,
       Object* setter,
       PropertyAttributes attributes);
   MUST_USE_RESULT MaybeObject* CreateAccessorPairFor(String* name);
   MUST_USE_RESULT MaybeObject* DefinePropertyAccessor(
       String* name,
       Object* getter,
       Object* setter,
       PropertyAttributes attributes);
 
-  // Returns the hidden properties backing store object, currently
-  // a StringDictionary, stored on this object.
+  // Returns the hidden properties backing store object stored on this object.
   // If no hidden properties object has been put on this object,
   // return undefined, unless create_if_absent is true, in which case
-  // a new dictionary is created, added to this object, and returned.
-  MUST_USE_RESULT MaybeObject* GetHiddenPropertiesDictionary(
+  // a new backing store is allocated, added to this object, and returned.
+  MUST_USE_RESULT MaybeObject* GetHiddenPropertiesArray(
       bool create_if_absent);
-  // Updates the existing hidden properties dictionary.
-  MUST_USE_RESULT MaybeObject* SetHiddenPropertiesDictionary(
-      StringDictionary* dictionary);
+  // Updates the existing hidden properties backing store.
+  MUST_USE_RESULT MaybeObject* SetHiddenPropertiesArray(
+      HiddenPropertiesArray* hidden_properties);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSObject);
 };
 
 
 // Common superclass for FixedArrays that allow implementations to share
 // common accessors and some code paths.
 class FixedArrayBase: public HeapObject {
  public:
   // [length]: length of the array.
@@ skipping 190 matching lines @@
 #endif
 
 #ifdef DEBUG
   void FixedDoubleArrayVerify();
 #endif
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedDoubleArray);
 };
 
+// HiddenPropertiesArray are fixed arrays used to store hidden properties.
+// Since we expect very few hidden properties, we use store the entries
+// linearly and use linear search for retrieval.
+class HiddenPropertiesArray: public FixedArray {
+ public:
+  // We allocate the backing store as FixedArray filled with holes.
+  MUST_USE_RESULT static inline MaybeObject* Allocate();
+
+  // Set a hidden property.  Return the current backing store afterwards
+  // (the backing store may be re-allocated when extended).
+  MUST_USE_RESULT inline MaybeObject* Set(String* key, Object* value);
+
+  // If the entry corresponding to the key is found, set the key of the entry
+  // to the hole and the value to undefined.  This way we can distinguish
+  // deleted entries from end of the list when we do linear search.
+  inline void Delete(String* key);
+  inline Object* Get(String* key);
+  static inline HiddenPropertiesArray* cast(Object* obj);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(HiddenPropertiesArray);
+};
+
 
 // DescriptorArrays are fixed arrays used to hold instance descriptors.
 // The format of the these objects is:
 // TODO(1399): It should be possible to make room for bit_field3 in the map
 //             without overloading the instance descriptors field in the map
 //             (and storing it in the DescriptorArray when the map has one).
 //   [0]: storage for bit_field3 for Map owning this object (Smi)
 //   [1]: point to a fixed array with (value, detail) pairs.
 //   [2]: next enumeration index (Smi), or pointer to small fixed array:
 //          [0]: next enumeration index (Smi)
@@ skipping 6442 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_