dart::CodeSerializationCluster Class Reference

Inheritance diagram for dart::CodeSerializationCluster:

Classes
struct	CodeOrderInfo

Public Member Functions
	CodeSerializationCluster (Heap *heap)
	~CodeSerializationCluster ()
void	Trace (Serializer *s, ObjectPtr object)
void	TracePool (Serializer *s, ObjectPoolPtr pool, bool only_call_targets)
intptr_t	NonDiscardedCodeCount ()
void	WriteAlloc (Serializer *s)
void	WriteAlloc (Serializer *s, CodePtr code)
void	WriteFill (Serializer *s)
void	WriteFill (Serializer *s, Snapshot::Kind kind, CodePtr code, bool deferred)
GrowableArray< CodePtr > *	objects ()
GrowableArray< CodePtr > *	deferred_objects ()
intptr_t	first_ref () const
intptr_t	first_deferred_ref () const
intptr_t	last_ref () const
Public Member Functions inherited from dart::SerializationCluster
	SerializationCluster (const char *name, intptr_t cid, intptr_t target_instance_size=kSizeVaries, bool is_canonical=false)
virtual	~SerializationCluster ()
virtual void	Trace (Serializer *serializer, ObjectPtr object)=0
virtual void	WriteAlloc (Serializer *serializer)=0
virtual void	WriteFill (Serializer *serializer)=0
void	WriteAndMeasureAlloc (Serializer *serializer)
void	WriteAndMeasureFill (Serializer *serializer)
const char *	name () const
intptr_t	cid () const
bool	is_canonical () const
bool	is_immutable () const
intptr_t	size () const
intptr_t	num_objects () const
intptr_t	target_memory_size () const
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static int	CompareCodeOrderInfo (CodeOrderInfo const *a, CodeOrderInfo const *b)
static void	Insert (Serializer *s, GrowableArray< CodeOrderInfo > *order_list, IntMap< intptr_t > *order_map, CodePtr code)
static void	Sort (Serializer *s, GrowableArray< CodePtr > *codes)
static void	Sort (Serializer *s, GrowableArray< Code * > *codes)
static const char *	MakeDisambiguatedCodeName (Serializer *s, CodePtr c)

Additional Inherited Members
Static Public Attributes inherited from dart::SerializationCluster
static constexpr intptr_t	kSizeVaries = -1
Protected Attributes inherited from dart::SerializationCluster
const char *const	name_
const intptr_t	cid_
const intptr_t	target_instance_size_
const bool	is_canonical_
const bool	is_immutable_
intptr_t	size_ = 0
intptr_t	num_objects_ = 0
intptr_t	target_memory_size_ = 0

Detailed Description

Definition at line 2603 of file app_snapshot.cc.

Constructor & Destructor Documentation

CodeSerializationCluster()

dart::CodeSerializationCluster::CodeSerializationCluster ( Heap *  heap )

inlineexplicit

Definition at line 2605 of file app_snapshot.cc.

      : SerializationCluster("Code", kCodeCid), array_(Array::Handle()) {}

~CodeSerializationCluster()

dart::CodeSerializationCluster::~CodeSerializationCluster ( )

inline

Definition at line 2607 of file app_snapshot.cc.

{}

Member Function Documentation

CompareCodeOrderInfo()

static int dart::CodeSerializationCluster::CompareCodeOrderInfo ( CodeOrderInfo const *  a, CodeOrderInfo const *  b  )

inlinestatic

Definition at line 2741 of file app_snapshot.cc.

                                                          {
    if (a->not_discarded < b->not_discarded) return -1;
    if (a->not_discarded > b->not_discarded) return 1;
    if (a->instructions_id < b->instructions_id) return -1;
    if (a->instructions_id > b->instructions_id) return 1;
    return 0;
  }

deferred_objects()

GrowableArray< CodePtr > * dart::CodeSerializationCluster::deferred_objects ( )

inline

Definition at line 2979 of file app_snapshot.cc.

{ return &deferred_objects_; }

first_deferred_ref()

intptr_t dart::CodeSerializationCluster::first_deferred_ref ( ) const

inline

Definition at line 2995 of file app_snapshot.cc.

{ return first_deferred_ref_; }

first_ref()

intptr_t dart::CodeSerializationCluster::first_ref ( ) const

inline

Definition at line 2994 of file app_snapshot.cc.

{ return first_ref_; }

Insert()

static void dart::CodeSerializationCluster::Insert ( Serializer *  s, GrowableArray< CodeOrderInfo > *  order_list, IntMap< intptr_t > *  order_map, CodePtr  code  )

inlinestatic

Definition at line 2750 of file app_snapshot.cc.

                                   {
    InstructionsPtr instr = code->untag()->instructions_;
    intptr_t key = static_cast<intptr_t>(instr);
    intptr_t instructions_id = 0;
 
    if (order_map->HasKey(key)) {
      // We are expected to merge code objects which point to the same
      // instructions in the precompiled mode.
      RELEASE_ASSERT(!FLAG_precompiled_mode);
      instructions_id = order_map->Lookup(key);
    } else {
      instructions_id = order_map->Length() + 1;
      order_map->Insert(key, instructions_id);
    }
    CodeOrderInfo info;
    info.code = code;
    info.instructions_id = instructions_id;
    info.not_discarded = Code::IsDiscarded(code) ? 0 : 1;
    order_list->Add(info);
  }

last_ref()

intptr_t dart::CodeSerializationCluster::last_ref ( ) const

inline

Definition at line 2996 of file app_snapshot.cc.

{ return last_ref_; }

MakeDisambiguatedCodeName()

static const char * dart::CodeSerializationCluster::MakeDisambiguatedCodeName ( Serializer *  s, CodePtr  c  )

inlinestatic

Definition at line 2981 of file app_snapshot.cc.

                                                                         {
    if (s->profile_writer() == nullptr) {
      return nullptr;
    }
 
    REUSABLE_CODE_HANDLESCOPE(s->thread());
    Code& code = reused_code_handle.Handle();
    code = c;
    return code.QualifiedName(
        NameFormattingParams::DisambiguatedWithoutClassName(
            Object::NameVisibility::kInternalName));
  }

NonDiscardedCodeCount()

intptr_t dart::CodeSerializationCluster::NonDiscardedCodeCount ( )

inline

Definition at line 2800 of file app_snapshot.cc.

                                   {
    intptr_t count = 0;
    for (auto code : objects_) {
      if (!Code::IsDiscarded(code)) {
        count++;
      }
    }
    return count;
  }

objects()

GrowableArray< CodePtr > * dart::CodeSerializationCluster::objects ( )

inline

Definition at line 2978 of file app_snapshot.cc.

{ return &objects_; }

Sort() [1/2]

static void dart::CodeSerializationCluster::Sort ( Serializer *  s, GrowableArray< Code * > *  codes  )

inlinestatic

Definition at line 2787 of file app_snapshot.cc.

                                                               {
    GrowableArray<CodeOrderInfo> order_list;
    IntMap<intptr_t> order_map;
    for (intptr_t i = 0; i < codes->length(); i++) {
      Insert(s, &order_list, &order_map, (*codes)[i]->ptr());
    }
    order_list.Sort(CompareCodeOrderInfo);
    ASSERT(order_list.length() == codes->length());
    for (intptr_t i = 0; i < order_list.length(); i++) {
      *(*codes)[i] = order_list[i].code;
    }
  }

Sort() [2/2]

static void dart::CodeSerializationCluster::Sort ( Serializer *  s, GrowableArray< CodePtr > *  codes  )

inlinestatic

Definition at line 2774 of file app_snapshot.cc.

                                                                 {
    GrowableArray<CodeOrderInfo> order_list;
    IntMap<intptr_t> order_map;
    for (intptr_t i = 0; i < codes->length(); i++) {
      Insert(s, &order_list, &order_map, (*codes)[i]);
    }
    order_list.Sort(CompareCodeOrderInfo);
    ASSERT(order_list.length() == codes->length());
    for (intptr_t i = 0; i < order_list.length(); i++) {
      (*codes)[i] = order_list[i].code;
    }
  }

Trace()

void dart::CodeSerializationCluster::Trace ( Serializer *  s, ObjectPtr  object  )

inlinevirtual

Implements dart::SerializationCluster.

Definition at line 2609 of file app_snapshot.cc.

                                              {
    CodePtr code = Code::RawCast(object);
 
    const bool is_deferred = !s->InCurrentLoadingUnitOrRoot(code);
    if (is_deferred) {
      s->RecordDeferredCode(code);
    } else {
      objects_.Add(code);
    }
 
    // Even if this code object is itself deferred we still need to scan
    // the pool for references to other code objects (which might reside
    // in the current loading unit).
    ObjectPoolPtr pool = code->untag()->object_pool_;
    if (s->kind() == Snapshot::kFullAOT) {
      TracePool(s, pool, /*only_call_targets=*/is_deferred);
    } else {
      if (s->InCurrentLoadingUnitOrRoot(pool)) {
        s->Push(pool);
      } else {
        TracePool(s, pool, /*only_call_targets=*/true);
      }
    }
 
    if (s->kind() == Snapshot::kFullJIT) {
      s->Push(code->untag()->deopt_info_array_);
      s->Push(code->untag()->static_calls_target_table_);
      s->Push(code->untag()->compressed_stackmaps_);
    } else if (s->kind() == Snapshot::kFullAOT) {
      // Note: we don't trace compressed_stackmaps_ because we are going to emit
      // a separate mapping table into RO data which is not going to be a real
      // heap object.
#if defined(DART_PRECOMPILER)
      auto const calls_array = code->untag()->static_calls_target_table_;
      if (calls_array != Array::null()) {
        // Some Code entries in the static calls target table may only be
        // accessible via here, so push the Code objects.
        array_ = calls_array;
        for (auto entry : StaticCallsTable(array_)) {
          auto kind = Code::KindField::decode(
              Smi::Value(entry.Get<Code::kSCallTableKindAndOffset>()));
          switch (kind) {
            case Code::kCallViaCode:
              // Code object in the pool.
              continue;
            case Code::kPcRelativeTTSCall:
              // TTS will be reachable through type object which itself is
              // in the pool.
              continue;
            case Code::kPcRelativeCall:
            case Code::kPcRelativeTailCall:
              auto destination = entry.Get<Code::kSCallTableCodeOrTypeTarget>();
              ASSERT(destination->IsHeapObject() && destination->IsCode());
              s->Push(destination);
          }
        }
      }
#else
      UNREACHABLE();
#endif
    }
 
    if (Code::IsDiscarded(code)) {
      ASSERT(s->kind() == Snapshot::kFullAOT && FLAG_dwarf_stack_traces_mode &&
             !FLAG_retain_code_objects);
      // Only object pool and static call table entries and the compressed
      // stack maps should be pushed.
      return;
    }
 
    s->Push(code->untag()->owner_);
    s->Push(code->untag()->exception_handlers_);
    s->Push(code->untag()->pc_descriptors_);
    s->Push(code->untag()->catch_entry_);
    if (!FLAG_precompiled_mode || !FLAG_dwarf_stack_traces_mode) {
      s->Push(code->untag()->inlined_id_to_function_);
      if (s->InCurrentLoadingUnitOrRoot(code->untag()->code_source_map_)) {
        s->Push(code->untag()->code_source_map_);
      }
    }
#if !defined(PRODUCT)
    s->Push(code->untag()->return_address_metadata_);
    if (FLAG_code_comments) {
      s->Push(code->untag()->comments_);
    }
#endif
  }

TracePool()

void dart::CodeSerializationCluster::TracePool ( Serializer *  s, ObjectPoolPtr  pool, bool  only_call_targets  )

inline

Definition at line 2697 of file app_snapshot.cc.

                                                                            {
    if (pool == ObjectPool::null()) {
      return;
    }
 
    const intptr_t length = pool->untag()->length_;
    uint8_t* entry_bits = pool->untag()->entry_bits();
    for (intptr_t i = 0; i < length; i++) {
      auto entry_type = ObjectPool::TypeBits::decode(entry_bits[i]);
      if (entry_type == ObjectPool::EntryType::kTaggedObject) {
        const ObjectPtr target = pool->untag()->data()[i].raw_obj_;
        // A field is a call target because its initializer may be called
        // indirectly by passing the field to the runtime. A const closure
        // is a call target because its function may be called indirectly
        // via a closure call.
        intptr_t cid = target->GetClassIdMayBeSmi();
        if (!only_call_targets || (cid == kCodeCid) || (cid == kFunctionCid) ||
            (cid == kFieldCid) || (cid == kClosureCid)) {
          s->Push(target);
        } else if (cid >= kNumPredefinedCids) {
          s->Push(s->isolate_group()->class_table()->At(cid));
        }
      }
    }
  }

WriteAlloc() [1/2]

void dart::CodeSerializationCluster::WriteAlloc ( Serializer *  s )

inlinevirtual

Implements dart::SerializationCluster.

Definition at line 2810 of file app_snapshot.cc.

                                 {
    const intptr_t non_discarded_count = NonDiscardedCodeCount();
    const intptr_t count = objects_.length();
    ASSERT(count == non_discarded_count || (s->kind() == Snapshot::kFullAOT));
 
    first_ref_ = s->next_ref_index();
    s->WriteUnsigned(non_discarded_count);
    for (auto code : objects_) {
      if (!Code::IsDiscarded(code)) {
        WriteAlloc(s, code);
      } else {
        // Mark discarded code unreachable, so that we could later
        // assign artificial references to it.
        s->heap()->SetObjectId(code, kUnreachableReference);
      }
    }
 
    s->WriteUnsigned(deferred_objects_.length());
    first_deferred_ref_ = s->next_ref_index();
    for (auto code : deferred_objects_) {
      ASSERT(!Code::IsDiscarded(code));
      WriteAlloc(s, code);
    }
    last_ref_ = s->next_ref_index() - 1;
  }

WriteAlloc() [2/2]

void dart::CodeSerializationCluster::WriteAlloc ( Serializer *  s, CodePtr  code  )

inline

Definition at line 2836 of file app_snapshot.cc.

                                               {
    ASSERT(!Code::IsDiscarded(code));
    s->AssignRef(code);
    AutoTraceObjectName(code, MakeDisambiguatedCodeName(s, code));
    const int32_t state_bits = code->untag()->state_bits_;
    s->Write<int32_t>(state_bits);
    target_memory_size_ += compiler::target::Code::InstanceSize(0);
  }

WriteFill() [1/2]

void dart::CodeSerializationCluster::WriteFill ( Serializer *  s )

inlinevirtual

Implements dart::SerializationCluster.

Definition at line 2845 of file app_snapshot.cc.

                                {
    Snapshot::Kind kind = s->kind();
    const intptr_t count = objects_.length();
    for (intptr_t i = 0; i < count; i++) {
      CodePtr code = objects_[i];
#if defined(DART_PRECOMPILER)
      if (FLAG_write_v8_snapshot_profile_to != nullptr &&
          Code::IsDiscarded(code)) {
        s->CreateArtificialNodeIfNeeded(code);
      }
#endif
      // Note: for discarded code this function will not write anything out
      // it is only called to produce information into snapshot profile.
      WriteFill(s, kind, code, /*deferred=*/false);
    }
    const intptr_t deferred_count = deferred_objects_.length();
    for (intptr_t i = 0; i < deferred_count; i++) {
      CodePtr code = deferred_objects_[i];
      WriteFill(s, kind, code, /*deferred=*/true);
    }
  }

WriteFill() [2/2]

void dart::CodeSerializationCluster::WriteFill ( Serializer *  s, Snapshot::Kind  kind, CodePtr  code, bool  deferred  )

inline

Definition at line 2867 of file app_snapshot.cc.

                                {
    const intptr_t bytes_written = s->bytes_written();
    AutoTraceObjectName(code, MakeDisambiguatedCodeName(s, code));
 
    intptr_t pointer_offsets_length =
        Code::PtrOffBits::decode(code->untag()->state_bits_);
    if (pointer_offsets_length != 0) {
      FATAL("Cannot serialize code with embedded pointers");
    }
    if (kind == Snapshot::kFullAOT && Code::IsDisabled(code)) {
      // Disabled code is fatal in AOT since we cannot recompile.
      s->UnexpectedObject(code, "Disabled code");
    }
 
    s->WriteInstructions(code->untag()->instructions_,
                         code->untag()->unchecked_offset_, code, deferred);
    if (kind == Snapshot::kFullJIT) {
      // TODO(rmacnak): Fix references to disabled code before serializing.
      // For now, we may write the FixCallersTarget or equivalent stub. This
      // will cause a fixup if this code is called.
      const uint32_t active_unchecked_offset =
          code->untag()->unchecked_entry_point_ - code->untag()->entry_point_;
      s->WriteInstructions(code->untag()->active_instructions_,
                           active_unchecked_offset, code, deferred);
    }
 
#if defined(DART_PRECOMPILER)
    if (FLAG_write_v8_snapshot_profile_to != nullptr) {
      // If we are writing V8 snapshot profile then attribute references going
      // through the object pool and static calls to the code object itself.
      if (kind == Snapshot::kFullAOT &&
          code->untag()->object_pool_ != ObjectPool::null()) {
        ObjectPoolPtr pool = code->untag()->object_pool_;
        // Non-empty per-code object pools should not be reachable in this mode.
        ASSERT(!s->HasRef(pool) || pool == Object::empty_object_pool().ptr());
        s->CreateArtificialNodeIfNeeded(pool);
        s->AttributePropertyRef(pool, "object_pool_");
      }
      if (kind != Snapshot::kFullJIT &&
          code->untag()->static_calls_target_table_ != Array::null()) {
        auto const table = code->untag()->static_calls_target_table_;
        // Non-empty static call target tables shouldn't be reachable in this
        // mode.
        ASSERT(!s->HasRef(table) || table == Object::empty_array().ptr());
        s->CreateArtificialNodeIfNeeded(table);
        s->AttributePropertyRef(table, "static_calls_target_table_");
      }
    }
#endif  // defined(DART_PRECOMPILER)
 
    if (Code::IsDiscarded(code)) {
      // No bytes should be written to represent this code.
      ASSERT(s->bytes_written() == bytes_written);
      // Only write instructions, compressed stackmaps and state bits
      // for the discarded Code objects.
      ASSERT(kind == Snapshot::kFullAOT && FLAG_dwarf_stack_traces_mode &&
             !FLAG_retain_code_objects);
#if defined(DART_PRECOMPILER)
      if (FLAG_write_v8_snapshot_profile_to != nullptr) {
        // Keep the owner as a (possibly artificial) node for snapshot analysis.
        const auto& owner = code->untag()->owner_;
        s->CreateArtificialNodeIfNeeded(owner);
        s->AttributePropertyRef(owner, "owner_");
      }
#endif
      return;
    }
 
    // No need to write object pool out if we are producing full AOT
    // snapshot with bare instructions.
    if (kind != Snapshot::kFullAOT) {
      if (s->InCurrentLoadingUnitOrRoot(code->untag()->object_pool_)) {
        WriteField(code, object_pool_);
      } else {
        WriteFieldValue(object_pool_, ObjectPool::null());
      }
    }
    WriteField(code, owner_);
    WriteField(code, exception_handlers_);
    WriteField(code, pc_descriptors_);
    WriteField(code, catch_entry_);
    if (s->kind() == Snapshot::kFullJIT) {
      WriteField(code, compressed_stackmaps_);
    }
    if (FLAG_precompiled_mode && FLAG_dwarf_stack_traces_mode) {
      WriteFieldValue(inlined_id_to_function_, Array::null());
      WriteFieldValue(code_source_map_, CodeSourceMap::null());
    } else {
      WriteField(code, inlined_id_to_function_);
      if (s->InCurrentLoadingUnitOrRoot(code->untag()->code_source_map_)) {
        WriteField(code, code_source_map_);
      } else {
        WriteFieldValue(code_source_map_, CodeSourceMap::null());
      }
    }
    if (kind == Snapshot::kFullJIT) {
      WriteField(code, deopt_info_array_);
      WriteField(code, static_calls_target_table_);
    }
 
#if !defined(PRODUCT)
    WriteField(code, return_address_metadata_);
    if (FLAG_code_comments) {
      WriteField(code, comments_);
    }
#endif
  }

---

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

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