[heap] Minor MC: Add marking

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 701 matching lines @@
   for (int i = 0; i < new_space_nodes_.length(); ++i) {
     Node* node = new_space_nodes_[i];
     DCHECK(node->is_in_new_space_list());
     if ((node->is_independent() || !node->is_active()) && node->IsWeak() &&
         is_unscavenged(isolate_->heap(), node->location())) {
       node->MarkPending();
     }
   }
 }
 
-
+template <GlobalHandles::IterationMode mode>

[ulan, 2016/11/15 19:57:21]

mode is unused in this function.

[Michael Lippautz, 2016/11/16 10:25:26]

Done. Worked by accident because none of our tests check against dupes in
callbacks.

 void GlobalHandles::IterateNewSpaceWeakUnmodifiedRoots(ObjectVisitor* v) {
   for (int i = 0; i < new_space_nodes_.length(); ++i) {
     Node* node = new_space_nodes_[i];
     DCHECK(node->is_in_new_space_list());
     if ((node->is_independent() || !node->is_active()) &&
         node->IsWeakRetainer()) {
       // Pending weak phantom handles die immediately. Everything else survives.
       if (node->IsPendingPhantomResetHandle()) {
         node->ResetPhantomHandle();
         ++number_of_phantom_handle_resets_;
       } else if (node->IsPendingPhantomCallback()) {
         node->CollectPhantomCallbackData(isolate(),
                                          &pending_phantom_callbacks_);
       } else {
         v->VisitPointer(node->location());
       }
     }
   }
 }
 
+template void GlobalHandles::IterateNewSpaceWeakUnmodifiedRoots<
+    GlobalHandles::HANDLE_PHANTOM_NODES>(ObjectVisitor* v);
+
+template void GlobalHandles::IterateNewSpaceWeakUnmodifiedRoots<
+    GlobalHandles::DONT_HANDLE_PHANTOM_NODES>(ObjectVisitor* v);
+
+void GlobalHandles::ResetNewSpaceHandlesForTesting() {

[ulan, 2016/11/15 19:57:21]

Would it be more robust to remember the state before changes and restore it
here, instead of undoing?

[Michael Lippautz, 2016/11/16 10:25:26]

Yes! Done.

+  for (int i = 0; i < new_space_nodes_.length(); ++i) {
+    Node* node = new_space_nodes_[i];
+    DCHECK(node->is_in_new_space_list());
+
+    if (node->IsWeak()) {
+      // Undo: IdentifyWeakUnmodifiedObjects.
+      if (node->is_active()) {
+        node->set_active(false);
+      }
+      // Undo: MarkNewSpaceWeakUnmodifiedObjectsPending.
+      if ((node->is_independent() || !node->is_active()) &&
+          node->state() == Node::PENDING) {
+        node->set_state(Node::WEAK);
+      }
+    }
+  }
+}
 
 DISABLE_CFI_PERF
 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);
@@ skipping 698 matching lines @@
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 }  // namespace internal
 }  // namespace v8