dart::ProgramVisitor Class Reference

#include <program_visitor.h>

Inheritance diagram for dart::ProgramVisitor:

Static Public Member Functions
static void	WalkProgram (Zone *zone, IsolateGroup *isolate_group, ClassVisitor *visitor)
static void	Dedup (Thread *thread)

Detailed Description

Definition at line 94 of file program_visitor.h.

Member Function Documentation

Dedup()

void dart::ProgramVisitor::Dedup ( Thread *  thread )

static

Definition at line 1409 of file program_visitor.cc.

                                         {
  BindStaticCalls(thread);
  ShareMegamorphicBuckets(thread);
  NormalizeAndDedupCompressedStackMaps(thread);
  DedupPcDescriptors(thread);
  DedupDeoptEntries(thread);
#if defined(DART_PRECOMPILER)
  DedupCatchEntryMovesMaps(thread);
  DedupUnlinkedCalls(thread);
  PruneSubclasses(thread);
#endif
  DedupCodeSourceMaps(thread);
  DedupLists(thread);
 
  // Reduces binary size but obfuscates profiler results.
  if (FLAG_dedup_instructions) {
    DedupInstructions(thread);
  }
}

WalkProgram()

void dart::ProgramVisitor::WalkProgram ( Zone *  zone, IsolateGroup *  isolate_group, ClassVisitor *  visitor  )

static

Definition at line 215 of file program_visitor.cc.

                                                        {
  auto const object_store = isolate_group->object_store();
  auto const heap = isolate_group->heap();
  ProgramWalker walker(zone, heap, visitor);
 
  // Walk through the libraries looking for visitable objects.
  const auto& libraries =
      GrowableObjectArray::Handle(zone, object_store->libraries());
  auto& lib = Library::Handle(zone);
  auto& cls = Class::Handle(zone);
 
  for (intptr_t i = 0; i < libraries.Length(); i++) {
    lib ^= libraries.At(i);
    ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
    while (it.HasNext()) {
      cls = it.GetNextClass();
      walker.AddToWorklist(cls);
    }
  }
 
  // If there's a global object pool, add any visitable objects.
  const auto& global_object_pool =
      ObjectPool::Handle(zone, object_store->global_object_pool());
  if (!global_object_pool.IsNull()) {
    auto& object = Object::Handle(zone);
    for (intptr_t i = 0; i < global_object_pool.Length(); i++) {
      auto const type = global_object_pool.TypeAt(i);
      if (type != ObjectPool::EntryType::kTaggedObject) continue;
      object = global_object_pool.ObjectAt(i);
      walker.AddToWorklist(object);
    }
  }
 
  if (visitor->IsFunctionVisitor()) {
    // Function objects not necessarily reachable from classes.
    ClosureFunctionsCache::ForAllClosureFunctions([&](const Function& fun) {
      walker.AddToWorklist(fun);
      ASSERT(!fun.HasImplicitClosureFunction());
      return true;  // Continue iteration.
    });
 
    // TODO(dartbug.com/43049): Use a more general solution and remove manual
    // tracking through object_store->ffi_callback_functions.
    if (object_store->ffi_callback_functions() != Array::null()) {
      auto& function = Function::Handle(zone);
      FfiCallbackFunctionSet set(object_store->ffi_callback_functions());
      FfiCallbackFunctionSet::Iterator it(&set);
      while (it.MoveNext()) {
        const intptr_t entry = it.Current();
        function ^= set.GetKey(entry);
        walker.AddToWorklist(function);
      }
      set.Release();
    }
  }
 
  if (visitor->IsCodeVisitor()) {
    // Code objects not necessarily reachable from functions.
    auto& code = Code::Handle(zone);
    const auto& dispatch_table_entries =
        Array::Handle(zone, object_store->dispatch_table_code_entries());
    if (!dispatch_table_entries.IsNull()) {
      for (intptr_t i = 0; i < dispatch_table_entries.Length(); i++) {
        code ^= dispatch_table_entries.At(i);
        walker.AddToWorklist(code);
      }
    }
  }
 
  // Walk the program starting from any roots we added to the worklist.
  walker.VisitWorklist();
}

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/program_visitor.h
• third_party/dart-lang/sdk/runtime/vm/program_visitor.cc