deps/v8/src/heap/visit-object.cc - main - githubmirror/node

deps/v8/src/heap/visit-object.cc
164 строки6 KB
Michaël Zasso
deps: update V8 to 13.6.233.8
02 май 2025, 16:06
02 май 2025, 16:06918fe04
// Copyright 2024 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/heap/visit-object.h"

#include "src/codegen/reloc-info.h"
#include "src/common/globals.h"
#include "src/heap/heap-visitor-inl.h"
#include "src/objects/heap-object.h"
#include "src/objects/instruction-stream.h"
#include "src/objects/visitors.h"

namespace v8::internal {

class ObjectVisitorForwarder final
    : public HeapVisitor<ObjectVisitorForwarder> {
 public:
  explicit ObjectVisitorForwarder(Isolate* isolate, ObjectVisitor* visitor)
      : HeapVisitor(isolate), visitor_(visitor) {}
  explicit ObjectVisitorForwarder(LocalIsolate* isolate, ObjectVisitor* visitor)
      : HeapVisitor(isolate), visitor_(visitor) {}

  static constexpr bool ShouldVisitMapPointer() { return false; }
  static constexpr bool ShouldUseUncheckedCast() { return true; }
  static constexpr bool ShouldVisitFullJSObject() { return true; }

  void VisitPointers(Tagged<HeapObject> host, ObjectSlot start,
                     ObjectSlot end) override {
    visitor_->VisitPointers(host, start, end);
  }

  void VisitPointers(Tagged<HeapObject> host, MaybeObjectSlot start,
                     MaybeObjectSlot end) override {
    visitor_->VisitPointers(host, start, end);
  }

  void VisitInstructionStreamPointer(Tagged<Code> host,
                                     InstructionStreamSlot slot) override {
    visitor_->VisitInstructionStreamPointer(host, slot);
  }

  void VisitCustomWeakPointers(Tagged<HeapObject> host, ObjectSlot start,
                               ObjectSlot end) override {
    visitor_->VisitCustomWeakPointers(host, start, end);
  }

  void VisitPointer(Tagged<HeapObject> host, ObjectSlot slot) override {
    visitor_->VisitPointers(host, slot, slot + 1);
  }

  void VisitPointer(Tagged<HeapObject> host, MaybeObjectSlot slot) override {
    visitor_->VisitPointers(host, slot, slot + 1);
  }

  void VisitCustomWeakPointer(Tagged<HeapObject> host,
                              ObjectSlot slot) override {
    visitor_->VisitCustomWeakPointer(host, slot);
  }

  void VisitCodeTarget(Tagged<InstructionStream> host,
                       RelocInfo* rinfo) override {
    visitor_->VisitCodeTarget(host, rinfo);
  }

  void VisitEmbeddedPointer(Tagged<InstructionStream> host,
                            RelocInfo* rinfo) override {
    visitor_->VisitEmbeddedPointer(host, rinfo);
  }

  void VisitExternalReference(Tagged<InstructionStream> host,
                              RelocInfo* rinfo) override {
    visitor_->VisitExternalReference(host, rinfo);
  }

  void VisitInternalReference(Tagged<InstructionStream> host,
                              RelocInfo* rinfo) override {
    visitor_->VisitInternalReference(host, rinfo);
  }

  void VisitOffHeapTarget(Tagged<InstructionStream> host,
                          RelocInfo* rinfo) override {
    visitor_->VisitOffHeapTarget(host, rinfo);
  }

  void VisitExternalPointer(Tagged<HeapObject> host,
                            ExternalPointerSlot slot) override {
    visitor_->VisitExternalPointer(host, slot);
  }

  void VisitCppHeapPointer(Tagged<HeapObject> host,
                           CppHeapPointerSlot slot) override {
    visitor_->VisitCppHeapPointer(host, slot);
  }

  void VisitEphemeron(Tagged<HeapObject> host, int index, ObjectSlot key,
                      ObjectSlot value) override {
    visitor_->VisitEphemeron(host, index, key, value);
  }

  void VisitIndirectPointer(Tagged<HeapObject> host, IndirectPointerSlot slot,
                            IndirectPointerMode mode) override {
    visitor_->VisitIndirectPointer(host, slot, mode);
  }

  void VisitProtectedPointer(Tagged<TrustedObject> host,
                             ProtectedPointerSlot slot) override {
    visitor_->VisitProtectedPointer(host, slot);
  }

  void VisitProtectedPointer(Tagged<TrustedObject> host,
                             ProtectedMaybeObjectSlot slot) override {
    visitor_->VisitProtectedPointer(host, slot);
  }

  void VisitTrustedPointerTableEntry(Tagged<HeapObject> host,
                                     IndirectPointerSlot slot) override {
    visitor_->VisitTrustedPointerTableEntry(host, slot);
  }

  void VisitJSDispatchTableEntry(Tagged<HeapObject> host,
                                 JSDispatchHandle handle) override {
    visitor_->VisitJSDispatchTableEntry(host, handle);
  }

  void VisitMapPointer(Tagged<HeapObject> host) override { UNREACHABLE(); }

 private:
  ObjectVisitor* const visitor_;
};

void VisitObject(Isolate* isolate, Tagged<HeapObject> object,
                 ObjectVisitor* visitor) {
  visitor->VisitMapPointer(object);
  ObjectVisitorForwarder forward_visitor(isolate, visitor);
  forward_visitor.Visit(object);
}

void VisitObject(LocalIsolate* isolate, Tagged<HeapObject> object,
                 ObjectVisitor* visitor) {
  visitor->VisitMapPointer(object);
  ObjectVisitorForwarder forward_visitor(isolate, visitor);
  forward_visitor.Visit(object);
}

void VisitObjectBody(Isolate* isolate, Tagged<HeapObject> object,
                     ObjectVisitor* visitor) {
  ObjectVisitorForwarder forward_visitor(isolate, visitor);
  forward_visitor.Visit(object);
}

void VisitObjectBody(Isolate* isolate, Tagged<Map> map,
                     Tagged<HeapObject> object, ObjectVisitor* visitor) {
  ObjectVisitorForwarder forward_visitor(isolate, visitor);
  forward_visitor.Visit(map, object);
}

void VisitObjectBody(LocalIsolate* isolate, Tagged<HeapObject> object,
                     ObjectVisitor* visitor) {
  ObjectVisitorForwarder forward_visitor(isolate, visitor);
  forward_visitor.Visit(object);
}

}  // namespace v8::internal