Changed runtime system to preserve the global property cells for deleted prop...

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 130 matching lines @@
   bool IsTransition() {
     PropertyType t = type();
     ASSERT(t != INTERCEPTOR);
     return t == MAP_TRANSITION || t == CONSTANT_TRANSITION;
   }
 
   PropertyAttributes attributes() { return AttributesField::decode(value_); }
 
   int index() { return IndexField::decode(value_); }
 
+  inline PropertyDetails AsDeleted();
+
   static bool IsValidIndex(int index) { return IndexField::is_valid(index); }
 
   bool IsReadOnly() { return (attributes() & READ_ONLY) != 0; }
   bool IsDontDelete() { return (attributes() & DONT_DELETE) != 0; }
   bool IsDontEnum() { return (attributes() & DONT_ENUM) != 0; }
+  bool IsDeleted() { return DeletedField::decode(value_) != 0;}
 
   // Bit fields in value_ (type, shift, size). Must be public so the
   // constants can be embedded in generated code.
   class TypeField:       public BitField<PropertyType,       0, 3> {};
   class AttributesField: public BitField<PropertyAttributes, 3, 3> {};
-  class IndexField:      public BitField<uint32_t,           6, 31-6> {};
+  class DeletedField:    public BitField<uint32_t,           6, 1> {};
+  class IndexField:      public BitField<uint32_t,           7, 31-7> {};
 
   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 whether to keep
@@ skipping 1009 matching lines @@
   // Sets the property value in a normalized object given a lookup result.
   // Handles the special representation of JS global objects.
   Object* SetNormalizedProperty(LookupResult* result, Object* value);
 
   // Sets the property value in a normalized object given (key, value, details).
   // Handles the special representation of JS global objects.
   Object* SetNormalizedProperty(String* name,
                                 Object* value,
                                 PropertyDetails details);
 
+  // Deletes the named property in a normalized object.
+  Object* DeleteNormalizedProperty(String* name);
+
   // Sets a property that currently has lazy loading.
   Object* SetLazyProperty(LookupResult* result,
                           String* name,
                           Object* value,
                           PropertyAttributes attributes);
 
   // Returns the class name ([[Class]] property in the specification).
   String* class_name();
 
   // Retrieve interceptors.
@@ skipping 627 matching lines @@
   }
 
   static const int kNumberOfElementsIndex = 0;
   static const int kCapacityIndex         = 1;
   static const int kPrefixStartIndex      = 2;
   static const int kElementsStartIndex    = kPrefixStartIndex + prefix_size;
   static const int kElementSize           = element_size;
   static const int kElementsStartOffset   =
       kHeaderSize + kElementsStartIndex * kPointerSize;
 
+  // Constant used for denoting a absent entry.
+  static const int kNotFound = -1;
+
  protected:
   // Find entry for key otherwise return -1.
   int FindEntry(HashTableKey* key);
 
   // Find the entry at which to insert element with the given key that
   // has the given hash value.
   uint32_t FindInsertionEntry(Object* key, uint32_t hash);
 
   // Returns the index for an entry (of the key)
   static inline int EntryToIndex(int entry) {
@@ skipping 76 matching lines @@
 // fast-case properties array.
 //
 // LookupCaches are used to avoid repeatedly searching instance
 // descriptors.
 class LookupCache: public HashTable<0, 2> {
  public:
   int Lookup(Map* map, String* name);
   Object* Put(Map* map, String* name, int offset);
   static inline LookupCache* cast(Object* obj);
 
-  // Constant returned by Lookup when the key was not found.
-  static const int kNotFound = -1;
-
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(LookupCache);
 };
 
 
 // Dictionary for keeping properties and elements in slow case.
 //
 // One element in the prefix is used for storing non-element
 // information about the dictionary.
 //
@@ skipping 2350 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_