I'd like to add addr field into EntryInfo struct.

src/hashmap.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 44 matching lines @@
     uint32_t hash;  // the full hash value for key
   };
 
   // If an entry with matching key is found, Lookup()
   // returns that entry. If no matching entry is found,
   // but insert is set, a new entry is inserted with
   // corresponding key, key hash, and NULL value.
   // Otherwise, NULL is returned.
   Entry* Lookup(void* key, uint32_t hash, bool insert);
 
   // Removes the entry with matching key.

[mnaganov (inactive), 2012/04/10 21:12:04]

Please update the comment.

-  void Remove(void* key, uint32_t hash);
+  void* Remove(void* key, uint32_t hash);
 
   // Empties the hash map (occupancy() == 0).
   void Clear();
 
   // The number of (non-empty) entries in the table.
   uint32_t occupancy() const { return occupancy_; }
 
   // The capacity of the table. The implementation
   // makes sure that occupancy is at most 80% of
   // the table capacity.
@@ skipping 62 matching lines @@
 
     return p;
   }
 
   // No entry found and none inserted.
   return NULL;
 }
 
 
 template<class P>
-void TemplateHashMapImpl<P>::Remove(void* key, uint32_t hash) {
+void* TemplateHashMapImpl<P>::Remove(void* key, uint32_t hash) {
   // Lookup the entry for the key to remove.
   Entry* p = Probe(key, hash);
   if (p->key == NULL) {
     // Key not found nothing to remove.
-    return;
+    return NULL;
   }
 
+  void* value = p->value;
   // To remove an entry we need to ensure that it does not create an empty
   // entry that will cause the search for another entry to stop too soon. If all
   // the entries between the entry to remove and the next empty slot have their
   // initial position inside this interval, clearing the entry to remove will
   // not break the search. If, while searching for the next empty entry, an
   // entry is encountered which does not have its initial position between the
   // entry to remove and the position looked at, then this entry can be moved to
   // the place of the entry to remove without breaking the search for it. The
   // entry made vacant by this move is now the entry to remove and the process
   // starts over.
@@ skipping 28 matching lines @@
     if ((q > p && (r <= p || r > q)) ||
         (q < p && (r <= p && r > q))) {
       *p = *q;
       p = q;
     }
   }
 
   // Clear the entry which is allowed to en emptied.
   p->key = NULL;
   occupancy_--;
+  return value;
 }
 
 
 template<class P>
 void TemplateHashMapImpl<P>::Clear() {
   // Mark all entries as empty.
   const Entry* end = map_end();
   for (Entry* p = map_; p < end; p++) {
     p->key = NULL;
   }
@@ skipping 116 matching lines @@
   Iterator begin() const { return Iterator(this, this->Start()); }
   Iterator end() const { return Iterator(this, NULL); }
   Iterator find(Key* key, bool insert = false) {
     return Iterator(this, this->Lookup(key, key->Hash(), insert));
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_HASHMAP_H_