Decouple root visitors from object visitors.

src/frames.h

 // Copyright 2012 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_FRAMES_H_
 #define V8_FRAMES_H_
 
 #include "src/allocation.h"
 #include "src/handles.h"
 #include "src/safepoint-table.h"
@@ skipping 12 matching lines @@
 
 void SetUpJSCallerSavedCodeData();
 
 // Return the code of the n-th saved register available to JavaScript.
 int JSCallerSavedCode(int n);
 
 
 // Forward declarations.
 class ExternalCallbackScope;
 class Isolate;
+class RootVisitor;
 class StackFrameIteratorBase;
 class ThreadLocalTop;
 class WasmInstanceObject;
 
 class InnerPointerToCodeCache {
  public:
   struct InnerPointerToCodeCacheEntry {
     Address inner_pointer;
     Code* code;
     SafepointEntry safepoint_entry;
@@ skipping 539 matching lines @@
   static inline Code* GetContainingCode(Isolate* isolate, Address pc);
 
   // Get the code object containing the given pc and fill in the
   // safepoint entry and the number of stack slots. The pc must be at
   // a safepoint.
   static Code* GetSafepointData(Isolate* isolate,
                                 Address pc,
                                 SafepointEntry* safepoint_entry,
                                 unsigned* stack_slots);
 
-  virtual void Iterate(ObjectVisitor* v) const = 0;
-  static void IteratePc(ObjectVisitor* v, Address* pc_address,
+  virtual void Iterate(RootVisitor* v) const = 0;
+  static void IteratePc(RootVisitor* v, Address* pc_address,
                         Address* constant_pool_address, Code* holder);
 
   // Sets a callback function for return-address rewriting profilers
   // to resolve the location of a return address to the location of the
   // profiler's stashed return address.
   static void SetReturnAddressLocationResolver(
       ReturnAddressLocationResolver resolver);
 
   // Resolves pc_address through the resolution address function if one is set.
   static inline Address* ResolveReturnAddressLocation(Address* pc_address);
@@ skipping 50 matching lines @@
 
 
 // Entry frames are used to enter JavaScript execution from C.
 class EntryFrame: public StackFrame {
  public:
   Type type() const override { return ENTRY; }
 
   Code* unchecked_code() const override;
 
   // Garbage collection support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   static EntryFrame* cast(StackFrame* frame) {
     DCHECK(frame->is_entry());
     return static_cast<EntryFrame*>(frame);
   }
   void SetCallerFp(Address caller_fp) override;
 
  protected:
   inline explicit EntryFrame(StackFrameIteratorBase* iterator);
 
@@ skipping 32 matching lines @@
 // Exit frames are used to exit JavaScript execution and go to C.
 class ExitFrame: public StackFrame {
  public:
   Type type() const override { return EXIT; }
 
   Code* unchecked_code() const override;
 
   Object*& code_slot() const;
 
   // Garbage collection support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   void SetCallerFp(Address caller_fp) override;
 
   static ExitFrame* cast(StackFrame* frame) {
     DCHECK(frame->is_exit());
     return static_cast<ExitFrame*>(frame);
   }
 
   // Compute the state and type of an exit frame given a frame
   // pointer. Used when constructing the first stack frame seen by an
@@ skipping 258 matching lines @@
   // Computes the address of the PC field in the standard frame given
   // by the provided frame pointer.
   static inline Address ComputePCAddress(Address fp);
 
   // Computes the address of the constant pool  field in the standard
   // frame given by the provided frame pointer.
   static inline Address ComputeConstantPoolAddress(Address fp);
 
   // Iterate over expression stack including stack handlers, locals,
   // and parts of the fixed part including context and code fields.
-  void IterateExpressions(ObjectVisitor* v) const;
+  void IterateExpressions(RootVisitor* v) const;
 
   // Returns the address of the n'th expression stack element.
   virtual Address GetExpressionAddress(int n) const;
 
   // Determines if the standard frame for the given frame pointer is
   // an arguments adaptor frame.
   static inline bool IsArgumentsAdaptorFrame(Address fp);
 
   // Determines if the standard frame for the given frame pointer is a
   // construct frame.
   static inline bool IsConstructFrame(Address fp);
 
   // Used by OptimizedFrames and StubFrames.
-  void IterateCompiledFrame(ObjectVisitor* v) const;
+  void IterateCompiledFrame(RootVisitor* v) const;
 
  private:
   friend class StackFrame;
   friend class SafeStackFrameIterator;
 };
 
 class JavaScriptFrame : public StandardFrame {
  public:
   Type type() const override { return JAVA_SCRIPT; }
 
@@ skipping 29 matching lines @@
   // about the inlined frames use {GetFunctions} and {Summarize}.
   bool HasInlinedFrames() const;
 
   // Check if this frame has "adapted" arguments in the sense that the
   // actual passed arguments are available in an arguments adaptor
   // frame below it on the stack.
   inline bool has_adapted_arguments() const;
   int GetArgumentsLength() const;
 
   // Garbage collection support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Printing support.
   void Print(StringStream* accumulator, PrintMode mode,
              int index) const override;
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
 
   // Return a list with {SharedFunctionInfo} objects of this frame.
   virtual void GetFunctions(List<SharedFunctionInfo*>* functions) const;
@@ skipping 31 matching lines @@
 
  protected:
   inline explicit JavaScriptFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
   virtual int GetNumberOfIncomingArguments() const;
 
   // Garbage collection support. Iterates over incoming arguments,
   // receiver, and any callee-saved registers.
-  void IterateArguments(ObjectVisitor* v) const;
+  void IterateArguments(RootVisitor* v) const;
 
   virtual void PrintFrameKind(StringStream* accumulator) const {}
 
  private:
   inline Object* function_slot_object() const;
 
   friend class StackFrameIteratorBase;
 };
 
 
 class StubFrame : public StandardFrame {
  public:
   Type type() const override { return STUB; }
 
   // GC support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
 
   // Lookup exception handler for current {pc}, returns -1 if none found. Only
   // TurboFan stub frames are supported. Also returns data associated with the
   // handler site:
   //  - TurboFan stub: Data is the stack slot count of the entire frame.
   int LookupExceptionHandlerInTable(int* data);
 
  protected:
   inline explicit StubFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
   virtual int GetNumberOfIncomingArguments() const;
 
   friend class StackFrameIteratorBase;
 };
 
 
 class OptimizedFrame : public JavaScriptFrame {
  public:
   Type type() const override { return OPTIMIZED; }
 
   // GC support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Return a list with {SharedFunctionInfo} objects of this frame.
   // The functions are ordered bottom-to-top (i.e. functions.last()
   // is the top-most activation)
   void GetFunctions(List<SharedFunctionInfo*>* functions) const override;
 
   void Summarize(
       List<FrameSummary>* frames,
       FrameSummary::Mode mode = FrameSummary::kExactSummary) const override;
 
@@ skipping 112 matching lines @@
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 class WasmCompiledFrame final : public StandardFrame {
  public:
   Type type() const override { return WASM_COMPILED; }
 
   // GC support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Printing support.
   void Print(StringStream* accumulator, PrintMode mode,
              int index) const override;
 
   // Lookup exception handler for current {pc}, returns -1 if none found. Also
   // returns the stack slot count of the entire frame.
   int LookupExceptionHandlerInTable(int* data);
 
   // Determine the code for the frame.
@@ skipping 21 matching lines @@
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 class WasmInterpreterEntryFrame final : public StandardFrame {
  public:
   Type type() const override { return WASM_INTERPRETER_ENTRY; }
 
   // GC support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Printing support.
   void Print(StringStream* accumulator, PrintMode mode,
              int index) const override;
 
   void Summarize(
       List<FrameSummary>* frames,
       FrameSummary::Mode mode = FrameSummary::kExactSummary) const override;
 
   // Determine the code for the frame.
@@ skipping 38 matching lines @@
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 class InternalFrame: public StandardFrame {
  public:
   Type type() const override { return INTERNAL; }
 
   // Garbage collection support.
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Determine the code for the frame.
   Code* unchecked_code() const override;
 
   static InternalFrame* cast(StackFrame* frame) {
     DCHECK(frame->is_internal());
     return static_cast<InternalFrame*>(frame);
   }
 
  protected:
   inline explicit InternalFrame(StackFrameIteratorBase* iterator);
 
   Address GetCallerStackPointer() const override;
 
  private:
   friend class StackFrameIteratorBase;
 };
 
 
 class StubFailureTrampolineFrame: public StandardFrame {
  public:
   Type type() const override { return STUB_FAILURE_TRAMPOLINE; }
 
   // Get the code associated with this frame.
   // This method could be called during marking phase of GC.
   Code* unchecked_code() const override;
 
-  void Iterate(ObjectVisitor* v) const override;
+  void Iterate(RootVisitor* v) const override;
 
   // Architecture-specific register description.
   static Register fp_register();
   static Register context_register();
   static Register constant_pool_pointer_register();
 
  protected:
   inline explicit StubFailureTrampolineFrame(
       StackFrameIteratorBase* iterator);
 
@@ skipping 168 matching lines @@
 
 
 // Reads all frames on the current stack and copies them into the current
 // zone memory.
 Vector<StackFrame*> CreateStackMap(Isolate* isolate, Zone* zone);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_FRAMES_H_