dart::VMSerializationRoots Class Reference

Inheritance diagram for dart::VMSerializationRoots:

Public Member Functions
	VMSerializationRoots (const WeakArray &symbols, bool should_write_symbols)
void	AddBaseObjects (Serializer *s)
void	PushRoots (Serializer *s)
void	WriteRoots (Serializer *s)
Public Member Functions inherited from dart::SerializationRoots
virtual	~SerializationRoots ()
virtual void	AddBaseObjects (Serializer *serializer)=0
virtual void	PushRoots (Serializer *serializer)=0
virtual void	WriteRoots (Serializer *serializer)=0
virtual const CompressedStackMaps &	canonicalized_stack_map_entries () const

Detailed Description

Definition at line 6804 of file app_snapshot.cc.

Constructor & Destructor Documentation

VMSerializationRoots()

dart::VMSerializationRoots::VMSerializationRoots ( const WeakArray &  symbols, bool  should_write_symbols  )

inlineexplicit

Definition at line 6806 of file app_snapshot.cc.

      : symbols_(symbols),
        should_write_symbols_(should_write_symbols),
        zone_(Thread::Current()->zone()) {}

Member Function Documentation

AddBaseObjects()

void dart::VMSerializationRoots::AddBaseObjects ( Serializer *  s )

inlinevirtual

Implements dart::SerializationRoots.

Definition at line 6812 of file app_snapshot.cc.

                                     {
    // These objects are always allocated by Object::InitOnce, so they are not
    // written into the snapshot.
 
    s->AddBaseObject(Object::null(), "Null", "null");
    s->AddBaseObject(Object::sentinel().ptr(), "Null", "sentinel");
    s->AddBaseObject(Object::transition_sentinel().ptr(), "Null",
                     "transition_sentinel");
    s->AddBaseObject(Object::optimized_out().ptr(), "Null", "<optimized out>");
    s->AddBaseObject(Object::empty_array().ptr(), "Array", "<empty_array>");
    s->AddBaseObject(Object::empty_instantiations_cache_array().ptr(), "Array",
                     "<empty_instantiations_cache_array>");
    s->AddBaseObject(Object::empty_subtype_test_cache_array().ptr(), "Array",
                     "<empty_subtype_test_cache_array>");
    s->AddBaseObject(Object::dynamic_type().ptr(), "Type", "<dynamic type>");
    s->AddBaseObject(Object::void_type().ptr(), "Type", "<void type>");
    s->AddBaseObject(Object::empty_type_arguments().ptr(), "TypeArguments",
                     "[]");
    s->AddBaseObject(Bool::True().ptr(), "bool", "true");
    s->AddBaseObject(Bool::False().ptr(), "bool", "false");
    ASSERT(Object::synthetic_getter_parameter_types().ptr() != Object::null());
    s->AddBaseObject(Object::synthetic_getter_parameter_types().ptr(), "Array",
                     "<synthetic getter parameter types>");
    ASSERT(Object::synthetic_getter_parameter_names().ptr() != Object::null());
    s->AddBaseObject(Object::synthetic_getter_parameter_names().ptr(), "Array",
                     "<synthetic getter parameter names>");
    s->AddBaseObject(Object::empty_context_scope().ptr(), "ContextScope",
                     "<empty>");
    s->AddBaseObject(Object::empty_object_pool().ptr(), "ObjectPool",
                     "<empty>");
    s->AddBaseObject(Object::empty_compressed_stackmaps().ptr(),
                     "CompressedStackMaps", "<empty>");
    s->AddBaseObject(Object::empty_descriptors().ptr(), "PcDescriptors",
                     "<empty>");
    s->AddBaseObject(Object::empty_var_descriptors().ptr(),
                     "LocalVarDescriptors", "<empty>");
    s->AddBaseObject(Object::empty_exception_handlers().ptr(),
                     "ExceptionHandlers", "<empty>");
    s->AddBaseObject(Object::empty_async_exception_handlers().ptr(),
                     "ExceptionHandlers", "<empty async>");
 
    for (intptr_t i = 0; i < ArgumentsDescriptor::kCachedDescriptorCount; i++) {
      s->AddBaseObject(ArgumentsDescriptor::cached_args_descriptors_[i],
                       "ArgumentsDescriptor", "<cached arguments descriptor>");
    }
    for (intptr_t i = 0; i < ICData::kCachedICDataArrayCount; i++) {
      s->AddBaseObject(ICData::cached_icdata_arrays_[i], "Array",
                       "<empty icdata entries>");
    }
 
    ClassTable* table = s->isolate_group()->class_table();
    for (intptr_t cid = kFirstInternalOnlyCid; cid <= kLastInternalOnlyCid;
         cid++) {
      // Error, CallSiteData has no class object.
      if (cid != kErrorCid && cid != kCallSiteDataCid) {
        ASSERT(table->HasValidClassAt(cid));
        s->AddBaseObject(
            table->At(cid), "Class",
            Class::Handle(table->At(cid))
                .NameCString(Object::NameVisibility::kInternalName));
      }
    }
    s->AddBaseObject(table->At(kDynamicCid), "Class", "dynamic");
    s->AddBaseObject(table->At(kVoidCid), "Class", "void");
 
    if (!Snapshot::IncludesCode(s->kind())) {
      for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
        s->AddBaseObject(StubCode::EntryAt(i).ptr());
      }
    }
  }

PushRoots()

void dart::VMSerializationRoots::PushRoots ( Serializer *  s )

inlinevirtual

Implements dart::SerializationRoots.

Definition at line 6884 of file app_snapshot.cc.

                                {
    if (should_write_symbols_) {
      s->Push(symbols_.ptr());
    } else {
      for (intptr_t i = 0; i < symbols_.Length(); i++) {
        s->Push(symbols_.At(i));
      }
    }
    if (Snapshot::IncludesCode(s->kind())) {
      for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
        s->Push(StubCode::EntryAt(i).ptr());
      }
    }
  }

WriteRoots()

void dart::VMSerializationRoots::WriteRoots ( Serializer *  s )

inlinevirtual

Implements dart::SerializationRoots.

Definition at line 6899 of file app_snapshot.cc.

                                 {
    s->WriteRootRef(should_write_symbols_ ? symbols_.ptr() : Object::null(),
                    "symbol-table");
    if (Snapshot::IncludesCode(s->kind())) {
      for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
        s->WriteRootRef(StubCode::EntryAt(i).ptr(),
                        zone_->PrintToString("Stub:%s", StubCode::NameAt(i)));
      }
    }
 
    if (!should_write_symbols_ && s->profile_writer() != nullptr) {
      // If writing V8 snapshot profile create an artificial node representing
      // VM isolate symbol table.
      ASSERT(!s->IsReachable(symbols_.ptr()));
      s->AssignArtificialRef(symbols_.ptr());
      const auto& symbols_snapshot_id = s->GetProfileId(symbols_.ptr());
      s->profile_writer()->SetObjectTypeAndName(symbols_snapshot_id, "Symbols",
                                                "vm_symbols");
      s->profile_writer()->AddRoot(symbols_snapshot_id);
      for (intptr_t i = 0; i < symbols_.Length(); i++) {
        s->profile_writer()->AttributeReferenceTo(
            symbols_snapshot_id, V8SnapshotProfileWriter::Reference::Element(i),
            s->GetProfileId(symbols_.At(i)));
      }
    }
  }

---

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

• third_party/dart-lang/sdk/runtime/vm/app_snapshot.cc