Decouple root visitors from object visitors.

src/snapshot/startup-serializer.cc

 // Copyright 2016 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/snapshot/startup-serializer.h"
 
 #include "src/objects-inl.h"
 #include "src/v8threads.h"
 
 namespace v8 {
@@ skipping 77 matching lines @@
     SerializerReference ref = reference_map_.Lookup(obj);
     CHECK(ref.is_back_reference() && ref.chunk_index() == 0);
   }
 }
 
 void StartupSerializer::SerializeWeakReferencesAndDeferred() {
   // This comes right after serialization of the partial snapshot, where we
   // add entries to the partial snapshot cache of the startup snapshot. Add
   // one entry with 'undefined' to terminate the partial snapshot cache.
   Object* undefined = isolate()->heap()->undefined_value();
-  VisitPointer(&undefined);
+  VisitRootPointer(Root::kPartialSnapshotCache, &undefined);
   isolate()->heap()->IterateWeakRoots(this, VISIT_ALL);
   SerializeDeferredObjects();
   Pad();
 }
 
 int StartupSerializer::PartialSnapshotCacheIndex(HeapObject* heap_object) {
   int index;
   if (!partial_cache_index_map_.LookupOrInsert(heap_object, &index)) {
     // This object is not part of the partial snapshot cache yet. Add it to the
     // startup snapshot so we can refer to it via partial snapshot index from
     // the partial snapshot.
-    VisitPointer(reinterpret_cast<Object**>(&heap_object));
+    VisitRootPointer(Root::kPartialSnapshotCache,
+                     reinterpret_cast<Object**>(&heap_object));
   }
   return index;
 }
 
 void StartupSerializer::Synchronize(VisitorSynchronization::SyncTag tag) {
   // We expect the builtins tag after builtins have been serialized.
   DCHECK(!serializing_builtins_ || tag == VisitorSynchronization::kBuiltins);
   serializing_builtins_ = (tag == VisitorSynchronization::kHandleScope);
   sink_.Put(kSynchronize, "Synchronize");
 }
@@ skipping 16 matching lines @@
   // Clear the stack limits to make the snapshot reproducible.
   // Reset it again afterwards.
   isolate->heap()->ClearStackLimits();
   isolate->heap()->IterateSmiRoots(this);
   isolate->heap()->SetStackLimits();
 
   isolate->heap()->IterateStrongRoots(this,
                                       VISIT_ONLY_STRONG_FOR_SERIALIZATION);
 }
 
-void StartupSerializer::VisitPointers(Object** start, Object** end) {
+void StartupSerializer::VisitRootPointers(Root root, Object** start,
+                                          Object** end) {
   if (start == isolate()->heap()->roots_array_start()) {
     // Serializing the root list needs special handling:
     // - The first pass over the root list only serializes immortal immovables.
     // - The second pass over the root list serializes the rest.
     // - Only root list elements that have been fully serialized can be
     //   referenced via as root by using kRootArray bytecodes.
     int skip = 0;
     for (Object** current = start; current < end; current++) {
       int root_index = static_cast<int>(current - start);
       if (RootShouldBeSkipped(root_index)) {
         skip += kPointerSize;
         continue;
       } else {
         if ((*current)->IsSmi()) {
           FlushSkip(skip);
           PutSmi(Smi::cast(*current));
         } else {
           SerializeObject(HeapObject::cast(*current), kPlain, kStartOfObject,
                           skip);
         }
         root_has_been_serialized_.set(root_index);
         skip = 0;
       }
     }
     FlushSkip(skip);
   } else {
-    Serializer::VisitPointers(start, end);
+    Serializer::VisitRootPointers(root, start, end);
   }
 }
 
 bool StartupSerializer::RootShouldBeSkipped(int root_index) {
   if (root_index == Heap::kStackLimitRootIndex ||
       root_index == Heap::kRealStackLimitRootIndex) {
     return true;
   }
   return Heap::RootIsImmortalImmovable(root_index) !=
          serializing_immortal_immovables_roots_;
 }
 
 }  // namespace internal
 }  // namespace v8