Changed scavenge GC to collect unmodified references

src/global-handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/global-handles.h"
 
 #include "src/api.h"
 #include "src/v8.h"
 #include "src/vm-state-inl.h"
 
@@ skipping 669 matching lines @@
         node->CollectPhantomCallbackData(isolate(),
                                          &pending_phantom_callbacks_);
       } else {
         v->VisitPointer(node->location());
       }
     }
   }
 }
 
 
+void GlobalHandles::IterateNewSpaceWeakRoots(ObjectVisitor* v,
+                                             WeakSlotCallback can_skip) {
+  for (int i = 0; i < new_space_nodes_.length(); ++i) {
+    Node* node = new_space_nodes_[i];
+    Object* object = node->object();
+    // If node->location is used instead of &object, import-expando-gc.html
+    // fails
+    if (node->IsWeak() && !can_skip(node->location()))
+      v->VisitPointer(&object);  // node->location());
+  }
+}
+
+

[mythria, 2015/09/21 09:54:23]

Here, I think node->location() is correct. One of the layout tests fails when I
use node->location(). When I pass &object the test is successful. I am not sure
if passing &object is correct. 

[jochen (gone - plz use gerrit), 2015/09/21 11:33:25]

that's odd - object and *node->location() should be the same.

what's the failure output of the test?

maybe add a CHECK() here that object* and *node->location() are the same. At
least in theory, object is nothing the GC knows about, so if anything moves, it
wouldn't be updated.

[rmcilroy, 2015/09/21 11:44:15]

One difference I can possibly think of is that VisitPointer would update the
pointer which is at the address passed to it when it moves the object from
From->To space. If we use &object then this is going to update the location on
the stack, and the handle will still point to the old location in the From space
won't it (if we use node->location() then it would update the location in the
handle to the To space)? I don't know much about the Scavenge visitor though so
I might be incorrect, also I'm not sure why this would cause the test to fail (I
would have thought the error would be the other way around where
node->location() would work but &object wouldn't).

[jochen (gone - plz use gerrit), 2015/09/21 11:54:19]

right, the visitor indeed updates the passed in location, node->location() is
definitely correct.

 bool GlobalHandles::IterateObjectGroups(ObjectVisitor* v,
                                         WeakSlotCallbackWithHeap can_skip) {
   ComputeObjectGroupsAndImplicitReferences();
   int last = 0;
   bool any_group_was_visited = false;
   for (int i = 0; i < object_groups_.length(); i++) {
     ObjectGroup* entry = object_groups_.at(i);
     DCHECK(entry != NULL);
 
     Object*** objects = entry->objects;
@@ skipping 574 matching lines @@
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 }  // namespace internal
 }  // namespace v8