Allow hidden properties and implement GetIdentityHash

src/heap.cc

 // 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 38 matching lines @@
 
 #define STRUCT_ALLOCATION(NAME, Name, name) Map* Heap::name##_map_;
   STRUCT_LIST(STRUCT_ALLOCATION)
 #undef STRUCT_ALLOCATION
 
 
 #define SYMBOL_ALLOCATION(name, string) String* Heap::name##_;
   SYMBOL_LIST(SYMBOL_ALLOCATION)
 #undef SYMBOL_ALLOCATION
 
+String* Heap::hidden_symbol_;
+
 NewSpace Heap::new_space_;
 OldSpace* Heap::old_pointer_space_ = NULL;
 OldSpace* Heap::old_data_space_ = NULL;
 OldSpace* Heap::code_space_ = NULL;
 MapSpace* Heap::map_space_ = NULL;
 LargeObjectSpace* Heap::lo_space_ = NULL;
 
 static const int kMinimumPromotionLimit = 2*MB;
 static const int kMinimumAllocationLimit = 8*MB;
 
@@ skipping 1137 matching lines @@
   obj = AllocateRawAsciiString(0, TENURED);
   if (obj->IsFailure()) return false;
   empty_string_ = String::cast(obj);
 
 #define SYMBOL_INITIALIZE(name, string)                 \
   obj = LookupAsciiSymbol(string);                      \
   if (obj->IsFailure()) return false;                   \
   (name##_) = String::cast(obj);
   SYMBOL_LIST(SYMBOL_INITIALIZE)
 #undef SYMBOL_INITIALIZE
+  
+  // Allocate the hidden symbol which is used to identify the hidden properties
+  // in JSObjects. The hash code has a special value so that it will not match
+  // the empty string when searching for the property. It cannot be part of the
+  // SYMBOL_LIST because it needs to be allocated manually with the special
+  // hash code in place. The hash code for the hidden_symbol is zero to ensure
+  // that it will always be at the first entry in property descriptors.
+  obj = AllocateSymbol(CStrVector(""), 0, String::kHashComputedMask);
+  if (obj->IsFailure()) return false;
+  hidden_symbol_ = String::cast(obj);
 
   // Allocate the proxy for __proto__.
   obj = AllocateProxy((Address) &Accessors::ObjectPrototype);
   if (obj->IsFailure()) return false;
   prototype_accessors_ = Proxy::cast(obj);
 
   // Allocate the code_stubs dictionary.
   obj = Dictionary::Allocate(4);
   if (obj->IsFailure()) return false;
   code_stubs_ = Dictionary::cast(obj);
@@ skipping 1408 matching lines @@
 #define STRUCT_MAP_ITERATE(NAME, Name, name) \
   v->VisitPointer(bit_cast<Object**, Map**>(&name##_map_));
   STRUCT_LIST(STRUCT_MAP_ITERATE);
 #undef STRUCT_MAP_ITERATE
   SYNCHRONIZE_TAG("struct_map");
 
 #define SYMBOL_ITERATE(name, string) \
   v->VisitPointer(bit_cast<Object**, String**>(&name##_));
   SYMBOL_LIST(SYMBOL_ITERATE)
 #undef SYMBOL_ITERATE
+  v->VisitPointer(bit_cast<Object**, String**>(&hidden_symbol_));
   SYNCHRONIZE_TAG("symbol");
 
   Bootstrapper::Iterate(v);
   SYNCHRONIZE_TAG("bootstrapper");
   Top::Iterate(v);
   SYNCHRONIZE_TAG("top");
   Debug::Iterate(v);
   SYNCHRONIZE_TAG("debug");
   CompilationCache::Iterate(v);
   SYNCHRONIZE_TAG("compilationcache");
@@ skipping 670 matching lines @@
 #ifdef DEBUG
 bool Heap::GarbageCollectionGreedyCheck() {
   ASSERT(FLAG_gc_greedy);
   if (Bootstrapper::IsActive()) return true;
   if (disallow_allocation_failure()) return true;
   return CollectGarbage(0, NEW_SPACE);
 }
 #endif
 
 } }  // namespace v8::internal