[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 362 matching lines @@
   // Handle specific callback - might be a weak reference in disguise.
   WeakCallbackInfo<void>::Callback weak_callback_;
 
   // Provided data for callback.  In FREE state, this is used for
   // the free list link.
   union {
     void* parameter;
     Node* next_free;
   } parameter_or_next_free_;
 
+#ifdef VERIFY_HEAP
+  friend std::vector<std::pair<void*, uint8_t>>
+  GlobalHandles::GetNewSpaceNodeStates();
+  friend void GlobalHandles::RestoreNewSpaceNodeStates(
+      const std::vector<std::pair<void*, uint8_t>>& states);
+#endif  // VERIFY_HEAP
+
   DISALLOW_COPY_AND_ASSIGN(Node);
 };
 
 
 class GlobalHandles::NodeBlock {
  public:
   static const int kSize = 256;
 
   explicit NodeBlock(GlobalHandles* global_handles, NodeBlock* next)
       : next_(next),
@@ skipping 319 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>
 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_;
+        if (mode == IterationMode::HANDLE_PHANTOM_NODES) {
+          node->ResetPhantomHandle();
+          ++number_of_phantom_handle_resets_;
+        }
       } else if (node->IsPendingPhantomCallback()) {
-        node->CollectPhantomCallbackData(isolate(),
-                                         &pending_phantom_callbacks_);
+        if (mode == IterationMode::HANDLE_PHANTOM_NODES) {
+          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);
+
+#ifdef VERIFY_HEAP
+
+std::vector<std::pair<void*, uint8_t>> GlobalHandles::GetNewSpaceNodeStates() {
+  std::vector<std::pair<void*, uint8_t>> states;
+  for (int i = 0; i < new_space_nodes_.length(); ++i) {
+    Node* node = new_space_nodes_[i];
+    DCHECK(node->is_in_new_space_list());
+    states.push_back(std::make_pair(static_cast<void*>(node), node->flags_));
+  }
+  return states;
+}
+
+void GlobalHandles::RestoreNewSpaceNodeStates(
+    const std::vector<std::pair<void*, uint8_t>>& states) {
+  for (auto pair : states) {
+    static_cast<Node*>(pair.first)->flags_ = pair.second;
+  }
+}
+
+#endif  // VERIFY_HEAP
 
 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