root-visitor.cc

Go to the documentation of this file.

#include <stack>
 
#include "src/allocator.h"
#include "src/arch/arch-base.h"
#include "src/garbage-collector.h"
#include "src/roots-inl.h"
#include "src/roots.h"
 
namespace broom {
void RootVisitor::VisitRegularRoot(const void* pointer) {
  const void* base_pointer =
      allocator_->GetBasePointerOfMaybeInnerPointer(pointer);
  if (base_pointer == nullptr) {
    return;
  }
  // A simple iterative DFS.
  std::stack<const void*> to_visit;
  to_visit.push(base_pointer);
  while (!to_visit.empty()) {
    const void* pointer_to_visit = to_visit.top();
    to_visit.pop();
    AllocatorFrontMetadata* metadata = UnsafeCast<AllocatorFrontMetadata*>(
        SafeCast<UintPtr>(pointer_to_visit) - Allocator::kFrontMetadataSize);
    // Check if we've already scanned this pointer to avoid cycles and to not
    // unnecessarily re-scan large parts of the graph.
    if (metadata->AlreadyScanned()) continue;
    // If we haven't scanned it yet, mark it as scanned and alive now.
    metadata->MarkScanned();
    UintPtr start = SafeCast<UintPtr>(pointer_to_visit);
    gc_->MarkAlive(SafeCast<const void*>(start));
    // Scan to the end, but exclude the metadata at the very end.
    const void* const* end = SafeCast<const void* const*>(
        start + metadata->Size() - Allocator::kFrontMetadataSize -
        Allocator::kBackMetadataSize);
    // Go through the allocation and look for pointers that we might want to
    // visit.
    for (const void* const* current = SafeCast<const void* const*>(start);
         current < end; ++current) {
      const void* maybe_inner = *current;
      const void* base_pointer =
          allocator_->GetBasePointerOfMaybeInnerPointer(maybe_inner);
      if (base_pointer != nullptr) {
        to_visit.push(base_pointer);
      }
    }
  }
}
 
BROOM_NOASAN BROOM_NOTSAN BROOM_NOINLINE void IterateStackAndVisitRootsImpl(
    RootVisitor* visitor, const void* const* stack_bottom,
    const void* const* stack_top) {
  BASSERT(IsAligned<kPointerSize>(stack_top), "Stack top is not aligned");
  BASSERT(IsAligned<kPointerSize>(stack_bottom), "Stack bottom is not aligned");
  for (const void* const* current = stack_top; current < stack_bottom;
       ++current) {
    const void* pointer = *current;
    if (pointer != nullptr) visitor->Visit<RootKind::kStack>(pointer);
  }
}
 
void RootVisitor::IterateStackAndVisitRoots() {
  void* stack_bottom = platform::GetStackBottom();
  IterateStackTrampoline(this, stack_bottom, &IterateStackAndVisitRootsImpl);
}
 
void RootVisitor::VisitStackRoot(const void* maybe_inner) {
  VisitRegularRoot(maybe_inner);
}
 
void RootVisitor::VisitExternalRoot(const ExternalRoot* external_root) {
  const void* const* end = SafeCast<const void* const*>(
      RoundDown<kPointerSize>(external_root->EndUintPtr()));
  const void* const* start = SafeCast<const void* const*>(
      RoundUp<kPointerSize>(external_root->StartUintPtr()));
  for (const void* const* current = start; current < end; ++current) {
    VisitRegularRoot(*current);
  }
}
 
void RootVisitor::VisitPreciseRoot(const PreciseRoot* precise_root) {
  precise_root->Class()->Visit(SafeCast<Visitor*>(this));
}
}  // namespace broom