Prototype of mark-and-compact support for Harmony weak maps.

src/objects.h

 // Copyright 2011 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 2965 matching lines @@
 
   // Looks up the value associated with the given key. The undefined value is
   // returned in case the key is not present.
   Object* Lookup(JSObject* key);
 
   // Adds (or overwrites) the value associated with the given key. Mapping a
   // key to the undefined value causes removal of the whole entry.
   MUST_USE_RESULT MaybeObject* Put(JSObject* key, Object* value);
 
  private:
+  friend class MarkCompactCollector;
+
   void AddEntry(int entry, JSObject* key, Object* value);
-  void RemoveEntry(int entry);
+  void RemoveEntry(int entry, Heap* heap);
+  inline void RemoveEntry(int entry);
+
+  // Returns the index to the value of an entry.
+  static inline int EntryToValueIndex(int entry) {
+    return EntryToIndex(entry) + 1;
+  }
 };
 
 
 // JSFunctionResultCache caches results of some JSFunction invocation.
 // It is a fixed array with fixed structure:
 //   [0]: factory function
 //   [1]: finger index
 //   [2]: current cache size
 //   [3]: dummy field.
 // The rest of array are key/value pairs.
@@ skipping 3623 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunctionProxy);
 };
 
 
 // The JSWeakMap describes EcmaScript Harmony weak maps
 class JSWeakMap: public JSObject {
  public:
   // [table]: the backing hash table mapping keys to values.
   DECL_ACCESSORS(table, ObjectHashTable)
 
+  // [next]: linked list of encountered weak maps during GC.
+  DECL_ACCESSORS(next, Object)
+
+  // Unchecked accessors to be used during GC.
+  inline ObjectHashTable* unchecked_table();
+
   // Casting.
   static inline JSWeakMap* cast(Object* obj);
 
 #ifdef OBJECT_PRINT
   inline void JSWeakMapPrint() {
     JSWeakMapPrint(stdout);
   }
   void JSWeakMapPrint(FILE* out);
 #endif
 #ifdef DEBUG
   void JSWeakMapVerify();
 #endif
 
   static const int kTableOffset = JSObject::kHeaderSize;
-  static const int kSize = kTableOffset + kPointerSize;
+  static const int kNextOffset = kTableOffset + kPointerSize;
+  static const int kSize = kNextOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
 };
 
 
 // Foreign describes objects pointing from JavaScript to C structures.
 // Since they cannot contain references to JS HeapObjects they can be
 // placed in old_data_space.
 class Foreign: public HeapObject {
@@ skipping 629 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_