Fix for HeapSnapshotAddressReuse test case.

src/heap-snapshot-generator.cc

 // Copyright 2013 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 381 matching lines @@
   // This fact is using in MoveObject method.
   entries_.Add(EntryInfo(0, NULL, 0));
 }
 
 
 void HeapObjectsMap::SnapshotGenerationFinished() {
   RemoveDeadEntries();
 }
 
 
 void HeapObjectsMap::MoveObject(Address from, Address to) {

[yurys, 2013/02/21 15:26:43]

Is it possible that an object is allocated (not moved) directly at an address of
already tracked object?

   ASSERT(to != NULL);
   ASSERT(from != NULL);
   if (from == to) return;
   void* from_value = entries_map_.Remove(from, AddressHash(from));
-  if (from_value == NULL) return;
-  int from_entry_info_index =
-      static_cast<int>(reinterpret_cast<intptr_t>(from_value));
-  entries_.at(from_entry_info_index).addr = to;
-  HashMap::Entry* to_entry = entries_map_.Lookup(to, AddressHash(to), true);
-  if (to_entry->value != NULL) {
-    int to_entry_info_index =
+  if (from_value == NULL) {
+    // We don't know the object that may occupy the place of a known object.

[yurys, 2013/02/21 15:26:43]

I'd rephrase like this:

"It may occur that some untracked object moves to an address X and there is a
tracked object at that address. In this case we should remove the entry as we
know that the object has died."

+    // In that case we need to remove the entry for this died known object.

[yurys, 2013/02/21 15:26:43]

died -> dead

+    void* to_value = entries_map_.Remove(to, AddressHash(to));
+    if (to_value != NULL) {
+      int to_entry_info_index =
+        static_cast<int>(reinterpret_cast<intptr_t>(to_value));
+      entries_.at(to_entry_info_index).addr = NULL;
+    }
+  } else {
+    HashMap::Entry* to_entry = entries_map_.Lookup(to, AddressHash(to), true);
+    if (to_entry->value != NULL) {
+      // We found the entry with to address for an old object.

[yurys, 2013/02/21 15:26:43]

the entry -> existing entry

+      // Without this operation we will have two EntryInfo's with the same
+      // value in addr field. It is bad because later at RemoveDeadEntries
+      // one of this entry will be removed with the corresponding entries_map_
+      // entry.
+      int to_entry_info_index =
         static_cast<int>(reinterpret_cast<intptr_t>(to_entry->value));
-    // Without this operation we will have two EntryInfo's with the same
-    // value in addr field. It is bad because later at RemoveDeadEntries
-    // one of this entry will be removed with the corresponding entries_map_
-    // entry.
-    entries_.at(to_entry_info_index).addr = NULL;
+      entries_.at(to_entry_info_index).addr = NULL;
+      int from_entry_info_index =
+        static_cast<int>(reinterpret_cast<intptr_t>(from_value));
+      entries_.at(from_entry_info_index).addr = to;
+      to_entry->value = reinterpret_cast<void*>(from_entry_info_index);

[yurys, 2013/02/21 15:26:43]

to_entry->value = from_value; ?

+    }
   }
-  to_entry->value = reinterpret_cast<void*>(from_entry_info_index);
 }
 
 
 SnapshotObjectId HeapObjectsMap::FindEntry(Address addr) {
   HashMap::Entry* entry = entries_map_.Lookup(addr, AddressHash(addr), false);
   if (entry == NULL) return 0;
   int entry_index = static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
   EntryInfo& entry_info = entries_.at(entry_index);
   ASSERT(static_cast<uint32_t>(entries_.length()) > entries_map_.occupancy());
   return entry_info.id;
@@ skipping 2250 matching lines @@
 
 
 void HeapSnapshotJSONSerializer::SortHashMap(
     HashMap* map, List<HashMap::Entry*>* sorted_entries) {
   for (HashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p))
     sorted_entries->Add(p);
   sorted_entries->Sort(SortUsingEntryValue);
 }
 
 } }  // namespace v8::internal