[heap] Minor MC: Add marking

src/global-handles.h

 // Copyright 2011 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.
 
 #ifndef V8_GLOBAL_HANDLES_H_
 #define V8_GLOBAL_HANDLES_H_
 
+#include <vector>
+
 #include "include/v8.h"
 #include "include/v8-profiler.h"
 
 #include "src/handles.h"
 #include "src/list.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 88 matching lines @@
   // embedder gets a null pointer instead.
   PHANTOM_WEAK,
   PHANTOM_WEAK_2_INTERNAL_FIELDS,
   // The handle is automatically reset by the garbage collector when
   // the object is no longer reachable.
   PHANTOM_WEAK_RESET_HANDLE
 };
 
 class GlobalHandles {
  public:
+  enum IterationMode { HANDLE_PHANTOM_NODES, DONT_HANDLE_PHANTOM_NODES };
+
   ~GlobalHandles();
 
   // Creates a new global handle that is alive until Destroy is called.
   Handle<Object> Create(Object* value);
 
   // Copy a global handle
   static Handle<Object> CopyGlobal(Object** location);
 
   // Destroy a global handle.
   static void Destroy(Object** location);
@@ skipping 94 matching lines @@
   // See the note above.
   void IterateNewSpaceWeakIndependentRoots(ObjectVisitor* v);
 
   // Finds weak independent or unmodified handles satisfying
   // the callback predicate and marks them as pending. See the note above.
   void MarkNewSpaceWeakUnmodifiedObjectsPending(
       WeakSlotCallbackWithHeap is_unscavenged);
 
   // Iterates over weak independent or unmodified handles.
   // See the note above.
+  template <IterationMode mode>
   void IterateNewSpaceWeakUnmodifiedRoots(ObjectVisitor* v);
 
   // Identify unmodified objects that are in weak state and marks them
   // unmodified
   void IdentifyWeakUnmodifiedObjects(WeakSlotCallback is_unmodified);
 
   // Iterate over objects in object groups that have at least one object
   // which requires visiting. The callback has to return true if objects
   // can be skipped and false otherwise.
   bool IterateObjectGroups(ObjectVisitor* v, WeakSlotCallbackWithHeap can_skip);
@@ skipping 43 matching lines @@
   void RemoveImplicitRefGroups();
 
   // Tear down the global handle structure.
   void TearDown();
 
   Isolate* isolate() { return isolate_; }
 
 #ifdef DEBUG
   void PrintStats();
   void Print();
-#endif
+#endif  // DEBUG
+
+#ifdef VERIFY_HEAP
+  typedef std::vector<std::pair<void*, uint8_t>> NewSpaceNodeStates;
+  NewSpaceNodeStates GetNewSpaceNodeStates();
+  void RestoreNewSpaceNodeStates(const NewSpaceNodeStates& states);
+#endif  // VERIFY_HEAP
 
  private:
   explicit GlobalHandles(Isolate* isolate);
 
   // Migrates data from the internal representation (object_group_connections_,
   // retainer_infos_ and implicit_ref_connections_) to the public and more
   // efficient representation (object_groups_ and implicit_ref_groups_).
   void ComputeObjectGroupsAndImplicitReferences();
 
   // v8::internal::List is inefficient even for small number of elements, if we
@@ skipping 149 matching lines @@
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_GLOBAL_HANDLES_H_