Decouple root visitors from object visitors.

src/frames.cc

 // 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.
 
 #include "src/frames.h"
 
 #include <memory>
 #include <sstream>
 
 #include "src/base/bits.h"
 #include "src/deoptimizer.h"
 #include "src/frames-inl.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/ic/ic-stats.h"
 #include "src/register-configuration.h"
 #include "src/safepoint-table.h"
 #include "src/string-stream.h"
+#include "src/visitors.h"
 #include "src/vm-state-inl.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-objects.h"
 
 namespace v8 {
 namespace internal {
 
 ReturnAddressLocationResolver
     StackFrame::return_address_location_resolver_ = NULL;
 
@@ skipping 370 matching lines @@
   *safepoint_entry = entry->safepoint_entry;
   *stack_slots = code->stack_slots();
   return code;
 }
 
 
 #ifdef DEBUG
 static bool GcSafeCodeContains(HeapObject* object, Address addr);
 #endif
 
-
-void StackFrame::IteratePc(ObjectVisitor* v, Address* pc_address,
+void StackFrame::IteratePc(RootVisitor* v, Address* pc_address,
                            Address* constant_pool_address, Code* holder) {
   Address pc = *pc_address;
   DCHECK(GcSafeCodeContains(holder, pc));
   unsigned pc_offset = static_cast<unsigned>(pc - holder->instruction_start());
   Object* code = holder;
-  v->VisitPointer(&code);
+  v->VisitRootPointer(Root::kTop, &code);
   if (code == holder) return;
   holder = reinterpret_cast<Code*>(code);
   pc = holder->instruction_start() + pc_offset;
   *pc_address = pc;
   if (FLAG_enable_embedded_constant_pool && constant_pool_address) {
     *constant_pool_address = holder->constant_pool();
   }
 }
 
 
@@ skipping 168 matching lines @@
     state->constant_pool_address = reinterpret_cast<Address*>(
         fp() + ExitFrameConstants::kConstantPoolOffset);
   }
 }
 
 
 void ExitFrame::SetCallerFp(Address caller_fp) {
   Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset) = caller_fp;
 }
 
-
-void ExitFrame::Iterate(ObjectVisitor* v) const {
+void ExitFrame::Iterate(RootVisitor* v) const {
   // The arguments are traversed as part of the expression stack of
   // the calling frame.
   IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
-  v->VisitPointer(&code_slot());
+  v->VisitRootPointer(Root::kTop, &code_slot());
 }
 
 
 Address ExitFrame::GetCallerStackPointer() const {
   return fp() + ExitFrameConstants::kCallerSPOffset;
 }
 
 
 StackFrame::Type ExitFrame::GetStateForFramePointer(Address fp, State* state) {
   if (fp == 0) return NONE;
@@ skipping 155 matching lines @@
 }
 
 bool StandardFrame::IsConstructor() const { return false; }
 
 void StandardFrame::Summarize(List<FrameSummary>* functions,
                               FrameSummary::Mode mode) const {
   // This should only be called on frames which override this method.
   UNREACHABLE();
 }
 
-void StandardFrame::IterateCompiledFrame(ObjectVisitor* v) const {
+void StandardFrame::IterateCompiledFrame(RootVisitor* v) const {
   // Make sure that we're not doing "safe" stack frame iteration. We cannot
   // possibly find pointers in optimized frames in that state.
   DCHECK(can_access_heap_objects());
 
   // Compute the safepoint information.
   unsigned stack_slots = 0;
   SafepointEntry safepoint_entry;
   Code* code = StackFrame::GetSafepointData(
       isolate(), pc(), &safepoint_entry, &stack_slots);
   unsigned slot_space = stack_slots * kPointerSize;
@@ skipping 39 matching lines @@
       (frame_header_size + StandardFrameConstants::kFixedFrameSizeAboveFp);
 
   Object** frame_header_base = &Memory::Object_at(fp() - frame_header_size);
   Object** frame_header_limit =
       &Memory::Object_at(fp() - StandardFrameConstants::kCPSlotSize);
   Object** parameters_base = &Memory::Object_at(sp());
   Object** parameters_limit = frame_header_base - slot_space / kPointerSize;
 
   // Visit the parameters that may be on top of the saved registers.
   if (safepoint_entry.argument_count() > 0) {
-    v->VisitPointers(parameters_base,
-                     parameters_base + safepoint_entry.argument_count());
+    v->VisitRootPointers(Root::kTop, parameters_base,
+                         parameters_base + safepoint_entry.argument_count());
     parameters_base += safepoint_entry.argument_count();
   }
 
   // Skip saved double registers.
   if (safepoint_entry.has_doubles()) {
     // Number of doubles not known at snapshot time.
     DCHECK(!isolate()->serializer_enabled());
     parameters_base += RegisterConfiguration::Crankshaft()
                            ->num_allocatable_double_registers() *
                        kDoubleSize / kPointerSize;
   }
 
   // Visit the registers that contain pointers if any.
   if (safepoint_entry.HasRegisters()) {
     for (int i = kNumSafepointRegisters - 1; i >=0; i--) {
       if (safepoint_entry.HasRegisterAt(i)) {
         int reg_stack_index = MacroAssembler::SafepointRegisterStackIndex(i);
-        v->VisitPointer(parameters_base + reg_stack_index);
+        v->VisitRootPointer(Root::kTop, parameters_base + reg_stack_index);
       }
     }
     // Skip the words containing the register values.
     parameters_base += kNumSafepointRegisters;
   }
 
   // We're done dealing with the register bits.
   uint8_t* safepoint_bits = safepoint_entry.bits();
   safepoint_bits += kNumSafepointRegisters >> kBitsPerByteLog2;
 
   // Visit the rest of the parameters if they are tagged.
   if (code->has_tagged_params()) {
-    v->VisitPointers(parameters_base, parameters_limit);
+    v->VisitRootPointers(Root::kTop, parameters_base, parameters_limit);
   }
 
   // Visit pointer spill slots and locals.
   for (unsigned index = 0; index < stack_slots; index++) {
     int byte_index = index >> kBitsPerByteLog2;
     int bit_index = index & (kBitsPerByte - 1);
     if ((safepoint_bits[byte_index] & (1U << bit_index)) != 0) {
-      v->VisitPointer(parameters_limit + index);
+      v->VisitRootPointer(Root::kTop, parameters_limit + index);
     }
   }
 
   // Visit the return address in the callee and incoming arguments.
   IteratePc(v, pc_address(), constant_pool_address(), code);
 
   if (!is_wasm() && !is_wasm_to_js()) {
     // If this frame has JavaScript ABI, visit the context (in stub and JS
     // frames) and the function (in JS frames).
-    v->VisitPointers(frame_header_base, frame_header_limit);
+    v->VisitRootPointers(Root::kTop, frame_header_base, frame_header_limit);
   }
 }
 
-
-void StubFrame::Iterate(ObjectVisitor* v) const {
-  IterateCompiledFrame(v);
-}
-
+void StubFrame::Iterate(RootVisitor* v) const { IterateCompiledFrame(v); }
 
 Code* StubFrame::unchecked_code() const {
   return isolate()->FindCodeObject(pc());
 }
 
 
 Address StubFrame::GetCallerStackPointer() const {
   return fp() + ExitFrameConstants::kCallerSPOffset;
 }
 
 
 int StubFrame::GetNumberOfIncomingArguments() const {
   return 0;
 }
 
 int StubFrame::LookupExceptionHandlerInTable(int* stack_slots) {
   Code* code = LookupCode();
   DCHECK(code->is_turbofanned());
   DCHECK_EQ(code->kind(), Code::BUILTIN);
   HandlerTable* table = HandlerTable::cast(code->handler_table());
   int pc_offset = static_cast<int>(pc() - code->entry());
   *stack_slots = code->stack_slots();
   return table->LookupReturn(pc_offset);
 }
 
-void OptimizedFrame::Iterate(ObjectVisitor* v) const {
-  IterateCompiledFrame(v);
-}
-
+void OptimizedFrame::Iterate(RootVisitor* v) const { IterateCompiledFrame(v); }
 
 void JavaScriptFrame::SetParameterValue(int index, Object* value) const {
   Memory::Object_at(GetParameterSlot(index)) = value;
 }
 
 
 bool JavaScriptFrame::IsConstructor() const {
   Address fp = caller_fp();
   if (has_adapted_arguments()) {
     // Skip the arguments adaptor frame and look at the real caller.
@@ skipping 777 matching lines @@
   func_name[func_name_len] = '\0';
   accumulator->Add("], function #%u ('%s'), pc=%p, pos=%d\n",
                    this->function_index(), func_name, pc, this->position());
   if (mode != OVERVIEW) accumulator->Add("\n");
 }
 
 Code* WasmCompiledFrame::unchecked_code() const {
   return isolate()->FindCodeObject(pc());
 }
 
-void WasmCompiledFrame::Iterate(ObjectVisitor* v) const {
+void WasmCompiledFrame::Iterate(RootVisitor* v) const {
   IterateCompiledFrame(v);
 }
 
 Address WasmCompiledFrame::GetCallerStackPointer() const {
   return fp() + ExitFrameConstants::kCallerSPOffset;
 }
 
 WasmInstanceObject* WasmCompiledFrame::wasm_instance() const {
   WasmInstanceObject* obj = wasm::GetOwningWasmInstance(LookupCode());
   // This is a live stack frame; it must have a live instance.
@@ skipping 39 matching lines @@
 
 int WasmCompiledFrame::LookupExceptionHandlerInTable(int* stack_slots) {
   DCHECK_NOT_NULL(stack_slots);
   Code* code = LookupCode();
   HandlerTable* table = HandlerTable::cast(code->handler_table());
   int pc_offset = static_cast<int>(pc() - code->entry());
   *stack_slots = code->stack_slots();
   return table->LookupReturn(pc_offset);
 }
 
-void WasmInterpreterEntryFrame::Iterate(ObjectVisitor* v) const {
+void WasmInterpreterEntryFrame::Iterate(RootVisitor* v) const {
   IterateCompiledFrame(v);
 }
 
 void WasmInterpreterEntryFrame::Print(StringStream* accumulator, PrintMode mode,
                                       int index) const {
   PrintIndex(accumulator, mode, index);
   accumulator->Add("WASM INTERPRETER ENTRY [");
   Script* script = this->script();
   accumulator->PrintName(script->name());
   accumulator->Add("]");
@@ skipping 225 matching lines @@
     accumulator->Add("  [%02d] : %o", i, GetParameter(i));
     if (expected != -1 && i >= expected) {
       accumulator->Add("  // not passed to callee");
     }
     accumulator->Add("\n");
   }
 
   accumulator->Add("}\n\n");
 }
 
-
-void EntryFrame::Iterate(ObjectVisitor* v) const {
+void EntryFrame::Iterate(RootVisitor* v) const {
   IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
 }
 
-
-void StandardFrame::IterateExpressions(ObjectVisitor* v) const {
+void StandardFrame::IterateExpressions(RootVisitor* v) const {
   const int offset = StandardFrameConstants::kLastObjectOffset;
   Object** base = &Memory::Object_at(sp());
   Object** limit = &Memory::Object_at(fp() + offset) + 1;
-  v->VisitPointers(base, limit);
+  v->VisitRootPointers(Root::kTop, base, limit);
 }
 
-
-void JavaScriptFrame::Iterate(ObjectVisitor* v) const {
+void JavaScriptFrame::Iterate(RootVisitor* v) const {
   IterateExpressions(v);
   IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
 }
 
-void InternalFrame::Iterate(ObjectVisitor* v) const {
+void InternalFrame::Iterate(RootVisitor* v) const {
   Code* code = LookupCode();
   IteratePc(v, pc_address(), constant_pool_address(), code);
   // Internal frames typically do not receive any arguments, hence their stack
   // only contains tagged pointers.
   // We are misusing the has_tagged_params flag here to tell us whether
   // the full stack frame contains only tagged pointers or only raw values.
   // This is used for the WasmCompileLazy builtin, where we actually pass
   // untagged arguments and also store untagged values on the stack.
   if (code->has_tagged_params()) IterateExpressions(v);
 }
 
-
-void StubFailureTrampolineFrame::Iterate(ObjectVisitor* v) const {
+void StubFailureTrampolineFrame::Iterate(RootVisitor* v) const {
   Object** base = &Memory::Object_at(sp());
   Object** limit = &Memory::Object_at(
       fp() + StubFailureTrampolineFrameConstants::kFixedHeaderBottomOffset);
-  v->VisitPointers(base, limit);
+  v->VisitRootPointers(Root::kTop, base, limit);
   base = &Memory::Object_at(fp() + StandardFrameConstants::kFunctionOffset);
   const int offset = StandardFrameConstants::kLastObjectOffset;
   limit = &Memory::Object_at(fp() + offset) + 1;
-  v->VisitPointers(base, limit);
+  v->VisitRootPointers(Root::kTop, base, limit);
   IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
 }
 
 
 Address StubFailureTrampolineFrame::GetCallerStackPointer() const {
   return fp() + StandardFrameConstants::kCallerSPOffset;
 }
 
 
 Code* StubFailureTrampolineFrame::unchecked_code() const {
@@ skipping 190 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8