dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
088524efa6a35bd64ea2ec00c60dae3111298334
sdk/runtime/vm/raw_object.h
T
Tess Strickland 45a46ca2b8 [vm] Add (S)LEB128 encoding/decoding to BaseWriteStream. 
Unlike cfc8e6de, this does _not_ replace the default variable length
encoding for {Read,Write}Streams, but insteads adds separate
{Read,Write}{S,}LEB128 methods to the appropriate classes. If we later
find the cause of the issues that led to the revert of cfc8e6de, it'll
be easy to switch over then.

Note that WriteLEB128 asserts that the value is non-negative if used
with a signed type (since negative values suggests that SLEB128 should
be used instead for minimal encoding).

Also removes the various other encoding and decoding methods for
(S)LEB128 across the codebase and changes those clients to use
{Read,Write}Streams instead.

Other cleanups:

* Various constant-related cleanups in datastream.h.

* Adds DART_FORCE_INLINE to ReadStream::ReadByte and uses it in the
  default variable length decoding methods for retrieving bytes
  from the stream instead of managing current_ by hand.

* Creates a canonical empty CompressedStackMaps instance and uses
  that instead of the null CompressedStackMaps instance in most cases.
  The only remaining (expected) use of the null CompressedStackMaps
  instance is for the global table in the object store when no global
  table exists (e.g., in JIT mode before any snapshotting).

* Moves CompressedStackMapsIterator from code_descriptors.h to an
  Iterator class within CompressedStackMaps in object.h (similar to
  PcDescriptors::Iterator), to limit friend declarations and because it
  conceptually makes more sense as part of CompressedStackMaps.

* Removed CompressedStackMaps::PayloadByte, since existing clients
  (CompressedStackMaps::Iterator, StackMapEntry in program_visitor.cc)
  are better served by just operating on the payload buffer directly
  (with appropriate NoSafepointScopes).

* WriteStreams no longer allocate their initial space on construction,
  but rather on the first write, so no allocation is performed by
  constructing a never-used WriteStream.

Cq-Include-Trybots: luci.dart.try:vm-kernel-precomp-linux-debug-x64-try,vm-kernel-precomp-linux-debug-simarm_x64-try,vm-kernel-precomp-mac-release-simarm64-try,vm-kernel-mac-debug-x64-try,vm-kernel-win-debug-x64-try,vm-kernel-win-debug-ia32-try,vm-kernel-precomp-win-release-x64-try,vm-kernel-ubsan-linux-release-x64-try,vm-kernel-tsan-linux-release-x64-try,vm-kernel-precomp-ubsan-linux-release-x64-try,vm-kernel-precomp-tsan-linux-release-x64-try,vm-kernel-precomp-msan-linux-release-x64-try,vm-kernel-precomp-asan-linux-release-x64-try,vm-kernel-msan-linux-release-x64-try,vm-kernel-asan-linux-release-x64-try
Change-Id: Ice63321abaa79157fbe9f230a864c8bba0e6dea9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/166421
Reviewed-by: Ryan Macnak <rmacnak@google.com>
Commit-Queue: Tess Strickland <sstrickl@google.com>
2020-10-09 10:08:16 +00:00

2917 lines
101 KiB
C++
Raw Blame History

// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#ifndef RUNTIME_VM_RAW_OBJECT_H_
#define RUNTIME_VM_RAW_OBJECT_H_
#if defined(SHOULD_NOT_INCLUDE_RUNTIME)
#error "Should not include runtime"
#endif
#include "platform/assert.h"
#include "platform/atomic.h"
#include "platform/thread_sanitizer.h"
#include "vm/class_id.h"
#include "vm/compiler/method_recognizer.h"
#include "vm/compiler/runtime_api.h"
#include "vm/exceptions.h"
#include "vm/globals.h"
#include "vm/pointer_tagging.h"
#include "vm/snapshot.h"
#include "vm/tagged_pointer.h"
#include "vm/token.h"
#include "vm/token_position.h"
// Currently we have two different axes for offset generation:
//
// * Target architecture
// * DART_PRECOMPILED_RUNTIME (i.e, AOT vs. JIT)
//
// That is, fields in ObjectLayout and its subclasses should only be included or
// excluded conditionally based on these factors. Otherwise, the generated
// offsets can be wrong (which should be caught by offset checking in dart.cc).
//
// TODO(dartbug.com/43646): Add DART_PRECOMPILER as another axis.
namespace dart {
// For now there are no compressed pointers.
typedef ObjectPtr RawCompressed;
// Forward declarations.
class Isolate;
class IsolateGroup;
#define DEFINE_FORWARD_DECLARATION(clazz) class clazz##Layout;
CLASS_LIST(DEFINE_FORWARD_DECLARATION)
#undef DEFINE_FORWARD_DECLARATION
class CodeStatistics;
#define VISIT_FROM(type, first) \
type* from() { return reinterpret_cast<type*>(&first); }
#define VISIT_TO(type, last) \
type* to() { return reinterpret_cast<type*>(&last); }
#define VISIT_TO_LENGTH(type, last) \
type* to(intptr_t length) { return reinterpret_cast<type*>(last); }
#define VISIT_NOTHING() int NothingToVisit();
#define ASSERT_UNCOMPRESSED(Type) \
ASSERT(SIZE_OF_DEREFERENCED_RETURNED_VALUE(Type##Layout, from) == kWordSize)
// For now there are no compressed pointers, so this assert is the same as
// the above.
#define ASSERT_COMPRESSED(Type) \
ASSERT(SIZE_OF_DEREFERENCED_RETURNED_VALUE(Type##Layout, from) == kWordSize)
#define ASSERT_NOTHING_TO_VISIT(Type) \
ASSERT(SIZE_OF_RETURNED_VALUE(Type##Layout, NothingToVisit) == sizeof(int))
enum TypedDataElementType {
#define V(name) k##name##Element,
CLASS_LIST_TYPED_DATA(V)
#undef V
};
#define SNAPSHOT_WRITER_SUPPORT() \
void WriteTo(SnapshotWriter* writer, intptr_t object_id, \
Snapshot::Kind kind, bool as_reference); \
friend class SnapshotWriter;
#define VISITOR_SUPPORT(object) \
static intptr_t Visit##object##Pointers(object##Ptr raw_obj, \
ObjectPointerVisitor* visitor);
#define HEAP_PROFILER_SUPPORT() friend class HeapProfiler;
#define RAW_OBJECT_IMPLEMENTATION(object) \
private: /* NOLINT */ \
VISITOR_SUPPORT(object) \
friend class object; \
friend class ObjectLayout; \
friend class Heap; \
friend class Interpreter; \
friend class InterpreterHelpers; \
friend class Simulator; \
friend class SimulatorHelpers; \
friend class OffsetsTable; \
DISALLOW_ALLOCATION(); \
DISALLOW_IMPLICIT_CONSTRUCTORS(object##Layout)
#define RAW_HEAP_OBJECT_IMPLEMENTATION(object) \
private: \
RAW_OBJECT_IMPLEMENTATION(object); \
SNAPSHOT_WRITER_SUPPORT() \
HEAP_PROFILER_SUPPORT() \
friend class object##SerializationCluster; \
friend class object##DeserializationCluster; \
friend class Serializer; \
friend class Deserializer; \
friend class Pass2Visitor;
// RawObject is the base class of all raw objects; even though it carries the
// tags_ field not all raw objects are allocated in the heap and thus cannot
// be dereferenced (e.g. RawSmi).
class ObjectLayout {
public:
// The tags field which is a part of the object header uses the following
// bit fields for storing tags.
enum TagBits {
kCardRememberedBit = 0,
kOldAndNotMarkedBit = 1, // Incremental barrier target.
kNewBit = 2, // Generational barrier target.
kOldBit = 3, // Incremental barrier source.
kOldAndNotRememberedBit = 4, // Generational barrier source.
kCanonicalBit = 5,
kReservedTagPos = 6,
kReservedTagSize = 2,
kSizeTagPos = kReservedTagPos + kReservedTagSize, // = 8
kSizeTagSize = 8,
kClassIdTagPos = kSizeTagPos + kSizeTagSize, // = 16
kClassIdTagSize = 16,
#if defined(HASH_IN_OBJECT_HEADER)
kHashTagPos = kClassIdTagPos + kClassIdTagSize, // = 32
kHashTagSize = 16,
#endif
};
static const intptr_t kGenerationalBarrierMask = 1 << kNewBit;
static const intptr_t kIncrementalBarrierMask = 1 << kOldAndNotMarkedBit;
static const intptr_t kBarrierOverlapShift = 2;
COMPILE_ASSERT(kOldAndNotMarkedBit + kBarrierOverlapShift == kOldBit);
COMPILE_ASSERT(kNewBit + kBarrierOverlapShift == kOldAndNotRememberedBit);
// The bit in the Smi tag position must be something that can be set to 0
// for a dead filler object of either generation.
// See Object::MakeUnusedSpaceTraversable.
COMPILE_ASSERT(kCardRememberedBit == 0);
// Encodes the object size in the tag in units of object alignment.
class SizeTag {
public:
typedef intptr_t Type;
static constexpr intptr_t kMaxSizeTagInUnitsOfAlignment =
((1 << ObjectLayout::kSizeTagSize) - 1);
static constexpr intptr_t kMaxSizeTag =
kMaxSizeTagInUnitsOfAlignment * kObjectAlignment;
static UNLESS_DEBUG(constexpr) uword encode(intptr_t size) {
return SizeBits::encode(SizeToTagValue(size));
}
static constexpr uword decode(uword tag) {
return TagValueToSize(SizeBits::decode(tag));
}
static UNLESS_DEBUG(constexpr) uword update(intptr_t size, uword tag) {
return SizeBits::update(SizeToTagValue(size), tag);
}
static UNLESS_DEBUG(constexpr) bool SizeFits(intptr_t size) {
DEBUG_ASSERT(Utils::IsAligned(size, kObjectAlignment));
return (size <= kMaxSizeTag);
}
private:
// The actual unscaled bit field used within the tag field.
class SizeBits
: public BitField<uint32_t, intptr_t, kSizeTagPos, kSizeTagSize> {};
static UNLESS_DEBUG(constexpr) intptr_t SizeToTagValue(intptr_t size) {
DEBUG_ASSERT(Utils::IsAligned(size, kObjectAlignment));
return !SizeFits(size) ? 0 : (size >> kObjectAlignmentLog2);
}
static constexpr intptr_t TagValueToSize(intptr_t value) {
return value << kObjectAlignmentLog2;
}
};
class ClassIdTag : public BitField<uint32_t,
ClassIdTagType,
kClassIdTagPos,
kClassIdTagSize> {};
COMPILE_ASSERT(kBitsPerByte * sizeof(ClassIdTagType) == kClassIdTagSize);
class CardRememberedBit
: public BitField<uint32_t, bool, kCardRememberedBit, 1> {};
class OldAndNotMarkedBit
: public BitField<uint32_t, bool, kOldAndNotMarkedBit, 1> {};
class NewBit : public BitField<uint32_t, bool, kNewBit, 1> {};
class CanonicalBit : public BitField<uint32_t, bool, kCanonicalBit, 1> {};
class OldBit : public BitField<uint32_t, bool, kOldBit, 1> {};
class OldAndNotRememberedBit
: public BitField<uint32_t, bool, kOldAndNotRememberedBit, 1> {};
class ReservedBits
: public BitField<uint32_t, intptr_t, kReservedTagPos, kReservedTagSize> {
};
class Tags {
public:
Tags() : tags_(0) {}
NO_SANITIZE_THREAD
operator uint32_t() const {
return *reinterpret_cast<const uint32_t*>(&tags_);
}
NO_SANITIZE_THREAD
uint32_t operator=(uint32_t tags) {
return *reinterpret_cast<uint32_t*>(&tags_) = tags;
}
NO_SANITIZE_THREAD
bool StrongCAS(uint32_t old_tags, uint32_t new_tags) {
return tags_.compare_exchange_strong(old_tags, new_tags,
std::memory_order_relaxed);
}
NO_SANITIZE_THREAD
bool WeakCAS(uint32_t old_tags, uint32_t new_tags) {
return tags_.compare_exchange_weak(old_tags, new_tags,
std::memory_order_relaxed);
}
template <class TagBitField>
NO_SANITIZE_THREAD typename TagBitField::Type Read() const {
return TagBitField::decode(*reinterpret_cast<const uint32_t*>(&tags_));
}
template <class TagBitField>
NO_SANITIZE_THREAD void UpdateBool(bool value) {
if (value) {
tags_.fetch_or(TagBitField::encode(true), std::memory_order_relaxed);
} else {
tags_.fetch_and(~TagBitField::encode(true), std::memory_order_relaxed);
}
}
template <class TagBitField>
NO_SANITIZE_THREAD void UpdateUnsynchronized(
typename TagBitField::Type value) {
*reinterpret_cast<uint32_t*>(&tags_) =
TagBitField::update(value, *reinterpret_cast<uint32_t*>(&tags_));
}
template <class TagBitField>
NO_SANITIZE_THREAD bool TryAcquire() {
uint32_t mask = TagBitField::encode(true);
uint32_t old_tags = tags_.fetch_or(mask, std::memory_order_relaxed);
return !TagBitField::decode(old_tags);
}
template <class TagBitField>
NO_SANITIZE_THREAD bool TryClear() {
uint32_t mask = ~TagBitField::encode(true);
uint32_t old_tags = tags_.fetch_and(mask, std::memory_order_relaxed);
return TagBitField::decode(old_tags);
}
private:
std::atomic<uint32_t> tags_;
COMPILE_ASSERT(sizeof(std::atomic<uint32_t>) == sizeof(uint32_t));
};
// Assumes this is a heap object.
bool IsNewObject() const {
uword addr = reinterpret_cast<uword>(this);
return (addr & kObjectAlignmentMask) == kNewObjectAlignmentOffset;
}
// Assumes this is a heap object.
bool IsOldObject() const {
uword addr = reinterpret_cast<uword>(this);
return (addr & kObjectAlignmentMask) == kOldObjectAlignmentOffset;
}
// Support for GC marking bit. Marked objects are either grey (not yet
// visited) or black (already visited).
bool IsMarked() const {
ASSERT(IsOldObject());
return !tags_.Read<OldAndNotMarkedBit>();
}
void SetMarkBit() {
ASSERT(IsOldObject());
ASSERT(!IsMarked());
tags_.UpdateBool<OldAndNotMarkedBit>(false);
}
void SetMarkBitUnsynchronized() {
ASSERT(IsOldObject());
ASSERT(!IsMarked());
tags_.UpdateUnsynchronized<OldAndNotMarkedBit>(false);
}
void ClearMarkBit() {
ASSERT(IsOldObject());
ASSERT(IsMarked());
tags_.UpdateBool<OldAndNotMarkedBit>(true);
}
// Returns false if the bit was already set.
DART_WARN_UNUSED_RESULT
bool TryAcquireMarkBit() {
ASSERT(IsOldObject());
return tags_.TryClear<OldAndNotMarkedBit>();
}
// Canonical objects have the property that two canonical objects are
// logically equal iff they are the same object (pointer equal).
bool IsCanonical() const { return tags_.Read<CanonicalBit>(); }
void SetCanonical() { tags_.UpdateBool<CanonicalBit>(true); }
void ClearCanonical() { tags_.UpdateBool<CanonicalBit>(false); }
bool InVMIsolateHeap() const;
// Support for GC remembered bit.
bool IsRemembered() const {
ASSERT(IsOldObject());
return !tags_.Read<OldAndNotRememberedBit>();
}
void SetRememberedBit() {
ASSERT(!IsRemembered());
ASSERT(!IsCardRemembered());
tags_.UpdateBool<OldAndNotRememberedBit>(false);
}
void ClearRememberedBit() {
ASSERT(IsOldObject());
tags_.UpdateBool<OldAndNotRememberedBit>(true);
}
DART_FORCE_INLINE
void AddToRememberedSet(Thread* thread) {
ASSERT(!this->IsRemembered());
this->SetRememberedBit();
thread->StoreBufferAddObject(ObjectPtr(this));
}
bool IsCardRemembered() const { return tags_.Read<CardRememberedBit>(); }
void SetCardRememberedBitUnsynchronized() {
ASSERT(!IsRemembered());
ASSERT(!IsCardRemembered());
tags_.UpdateUnsynchronized<CardRememberedBit>(true);
}
intptr_t GetClassId() const { return tags_.Read<ClassIdTag>(); }
intptr_t HeapSize() const {
uint32_t tags = tags_;
intptr_t result = SizeTag::decode(tags);
if (result != 0) {
#if defined(DEBUG)
// TODO(22501) Array::MakeFixedLength has a race with this code: we might
// have loaded tags field and then MakeFixedLength could have updated it
// leading to inconsistency between HeapSizeFromClass() and
// SizeTag::decode(tags). We are working around it by reloading tags_ and
// recomputing size from tags.
const intptr_t size_from_class = HeapSizeFromClass(tags);
if ((result > size_from_class) && (GetClassId() == kArrayCid) &&
(tags_ != tags)) {
result = SizeTag::decode(tags_);
}
ASSERT(result == size_from_class);
#endif
return result;
}
result = HeapSizeFromClass(tags);
ASSERT(result > SizeTag::kMaxSizeTag);
return result;
}
// This variant must not deference this->tags_.
intptr_t HeapSize(uint32_t tags) const {
intptr_t result = SizeTag::decode(tags);
if (result != 0) {
return result;
}
result = HeapSizeFromClass(tags);
ASSERT(result > SizeTag::kMaxSizeTag);
return result;
}
bool Contains(uword addr) const {
intptr_t this_size = HeapSize();
uword this_addr = ObjectLayout::ToAddr(this);
return (addr >= this_addr) && (addr < (this_addr + this_size));
}
void Validate(IsolateGroup* isolate_group) const;
bool FindObject(FindObjectVisitor* visitor);
// This function may access the class-ID in the header, but it cannot access
// the actual class object, because the sliding compactor uses this function
// while the class objects are being moved.
intptr_t VisitPointers(ObjectPointerVisitor* visitor) {
// Fall back to virtual variant for predefined classes
intptr_t class_id = GetClassId();
if (class_id < kNumPredefinedCids) {
return VisitPointersPredefined(visitor, class_id);
}
// Calculate the first and last raw object pointer fields.
intptr_t instance_size = HeapSize();
uword obj_addr = ToAddr(this);
uword from = obj_addr + sizeof(ObjectLayout);
uword to = obj_addr + instance_size - kWordSize;
const auto first = reinterpret_cast<ObjectPtr*>(from);
const auto last = reinterpret_cast<ObjectPtr*>(to);
#if defined(SUPPORT_UNBOXED_INSTANCE_FIELDS)
const auto unboxed_fields_bitmap =
visitor->shared_class_table()->GetUnboxedFieldsMapAt(class_id);
if (!unboxed_fields_bitmap.IsEmpty()) {
intptr_t bit = sizeof(ObjectLayout) / kWordSize;
for (ObjectPtr* current = first; current <= last; current++) {
if (!unboxed_fields_bitmap.Get(bit++)) {
visitor->VisitPointer(current);
}
}
} else {
visitor->VisitPointers(first, last);
}
#else
// Call visitor function virtually
visitor->VisitPointers(first, last);
#endif // defined(SUPPORT_UNBOXED_INSTANCE_FIELDS)
return instance_size;
}
template <class V>
intptr_t VisitPointersNonvirtual(V* visitor) {
// Fall back to virtual variant for predefined classes
intptr_t class_id = GetClassId();
if (class_id < kNumPredefinedCids) {
return VisitPointersPredefined(visitor, class_id);
}
// Calculate the first and last raw object pointer fields.
intptr_t instance_size = HeapSize();
uword obj_addr = ToAddr(this);
uword from = obj_addr + sizeof(ObjectLayout);
uword to = obj_addr + instance_size - kWordSize;
const auto first = reinterpret_cast<ObjectPtr*>(from);
const auto last = reinterpret_cast<ObjectPtr*>(to);
#if defined(SUPPORT_UNBOXED_INSTANCE_FIELDS)
const auto unboxed_fields_bitmap =
visitor->shared_class_table()->GetUnboxedFieldsMapAt(class_id);
if (!unboxed_fields_bitmap.IsEmpty()) {
intptr_t bit = sizeof(ObjectLayout) / kWordSize;
for (ObjectPtr* current = first; current <= last; current++) {
if (!unboxed_fields_bitmap.Get(bit++)) {
visitor->V::VisitPointers(current, current);
}
}
} else {
visitor->V::VisitPointers(first, last);
}
#else
// Call visitor function non-virtually
visitor->V::VisitPointers(first, last);
#endif // defined(SUPPORT_UNBOXED_INSTANCE_FIELDS)
return instance_size;
}
// This variant ensures that we do not visit the extra slot created from
// rounding up instance sizes up to the allocation unit.
void VisitPointersPrecise(Isolate* isolate, ObjectPointerVisitor* visitor);
static ObjectPtr FromAddr(uword addr) {
// We expect the untagged address here.
ASSERT((addr & kSmiTagMask) != kHeapObjectTag);
return static_cast<ObjectPtr>(addr + kHeapObjectTag);
}
static uword ToAddr(const ObjectLayout* raw_obj) {
return reinterpret_cast<uword>(raw_obj);
}
static uword ToAddr(const ObjectPtr raw_obj) {
return static_cast<uword>(raw_obj) - kHeapObjectTag;
}
static bool IsCanonical(intptr_t value) {
return CanonicalBit::decode(value);
}
private:
Tags tags_; // Various object tags (bits).
#if defined(HASH_IN_OBJECT_HEADER)
// On 64 bit there is a hash field in the header for the identity hash.
uint32_t hash_;
#elif defined(IS_SIMARM_X64)
// On simarm_x64 the hash isn't used, but we need the padding anyway so that
// the object layout fits assumptions made about X64.
uint32_t padding_;
#endif
intptr_t VisitPointersPredefined(ObjectPointerVisitor* visitor,
intptr_t class_id);
intptr_t HeapSizeFromClass(uint32_t tags) const;
void SetClassId(intptr_t new_cid) {
tags_.UpdateUnsynchronized<ClassIdTag>(new_cid);
}
// All writes to heap objects should ultimately pass through one of the
// methods below or their counterparts in Object, to ensure that the
// write barrier is correctly applied.
template <typename type, std::memory_order order = std::memory_order_relaxed>
type LoadPointer(type const* addr) {
return reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
->load(order);
}
template <typename type, std::memory_order order = std::memory_order_relaxed>
void StorePointer(type const* addr, type value) {
reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
->store(value, order);
if (value->IsHeapObject()) {
CheckHeapPointerStore(value, Thread::Current());
}
}
template <typename type>
void StorePointer(type const* addr, type value, Thread* thread) {
*const_cast<type*>(addr) = value;
if (value->IsHeapObject()) {
CheckHeapPointerStore(value, thread);
}
}
template <typename type>
void StorePointerUnaligned(type const* addr, type value, Thread* thread) {
StoreUnaligned(const_cast<type*>(addr), value);
if (value->IsHeapObject()) {
CheckHeapPointerStore(value, thread);
}
}
DART_FORCE_INLINE
void CheckHeapPointerStore(ObjectPtr value, Thread* thread) {
uint32_t source_tags = this->tags_;
uint32_t target_tags = value->ptr()->tags_;
if (((source_tags >> kBarrierOverlapShift) & target_tags &
thread->write_barrier_mask()) != 0) {
if (value->IsNewObject()) {
// Generational barrier: record when a store creates an
// old-and-not-remembered -> new reference.
AddToRememberedSet(thread);
} else {
// Incremental barrier: record when a store creates an
// old -> old-and-not-marked reference.
ASSERT(value->IsOldObject());
#if !defined(TARGET_ARCH_IA32)
if (ClassIdTag::decode(target_tags) == kInstructionsCid) {
// Instruction pages may be non-writable. Defer marking.
thread->DeferredMarkingStackAddObject(value);
return;
}
#endif
if (value->ptr()->TryAcquireMarkBit()) {
thread->MarkingStackAddObject(value);
}
}
}
}
template <typename type, std::memory_order order = std::memory_order_relaxed>
void StoreArrayPointer(type const* addr, type value) {
reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
->store(value, order);
if (value->IsHeapObject()) {
CheckArrayPointerStore(addr, value, Thread::Current());
}
}
template <typename type>
void StoreArrayPointer(type const* addr, type value, Thread* thread) {
*const_cast<type*>(addr) = value;
if (value->IsHeapObject()) {
CheckArrayPointerStore(addr, value, thread);
}
}
template <typename type>
DART_FORCE_INLINE void CheckArrayPointerStore(type const* addr,
ObjectPtr value,
Thread* thread) {
uint32_t source_tags = this->tags_;
uint32_t target_tags = value->ptr()->tags_;
if (((source_tags >> kBarrierOverlapShift) & target_tags &
thread->write_barrier_mask()) != 0) {
if (value->IsNewObject()) {
// Generational barrier: record when a store creates an
// old-and-not-remembered -> new reference.
ASSERT(!this->IsRemembered());
if (this->IsCardRemembered()) {
RememberCard(reinterpret_cast<ObjectPtr const*>(addr));
} else {
this->SetRememberedBit();
thread->StoreBufferAddObject(static_cast<ObjectPtr>(this));
}
} else {
// Incremental barrier: record when a store creates an
// old -> old-and-not-marked reference.
ASSERT(value->IsOldObject());
#if !defined(TARGET_ARCH_IA32)
if (ClassIdTag::decode(target_tags) == kInstructionsCid) {
// Instruction pages may be non-writable. Defer marking.
thread->DeferredMarkingStackAddObject(value);
return;
}
#endif
if (value->ptr()->TryAcquireMarkBit()) {
thread->MarkingStackAddObject(value);
}
}
}
}
// Use for storing into an explicitly Smi-typed field of an object
// (i.e., both the previous and new value are Smis).
void StoreSmi(SmiPtr const* addr, SmiPtr value) {
// Can't use Contains, as array length is initialized through this method.
ASSERT(reinterpret_cast<uword>(addr) >= ObjectLayout::ToAddr(this));
*const_cast<SmiPtr*>(addr) = value;
}
NO_SANITIZE_THREAD
void StoreSmiIgnoreRace(SmiPtr const* addr, SmiPtr value) {
// Can't use Contains, as array length is initialized through this method.
ASSERT(reinterpret_cast<uword>(addr) >= ObjectLayout::ToAddr(this));
*const_cast<SmiPtr*>(addr) = value;
}
protected:
friend class StoreBufferUpdateVisitor; // RememberCard
void RememberCard(ObjectPtr const* slot);
friend class Array;
friend class ByteBuffer;
friend class CidRewriteVisitor;
friend class Closure;
friend class Code;
friend class Pointer;
friend class Double;
friend class DynamicLibrary;
friend class ForwardPointersVisitor; // StorePointer
friend class FreeListElement;
friend class Function;
friend class GCMarker;
friend class ExternalTypedData;
friend class ForwardList;
friend class GrowableObjectArray; // StorePointer
friend class Heap;
friend class ClassStatsVisitor;
template <bool>
friend class MarkingVisitorBase;
friend class Mint;
friend class Object;
friend class OneByteString; // StoreSmi
friend class InstanceLayout;
friend class Scavenger;
template <bool>
friend class ScavengerVisitorBase;
friend class ImageReader; // tags_ check
friend class ImageWriter;
friend class AssemblyImageWriter;
friend class BlobImageWriter;
friend class SnapshotReader;
friend class Deserializer;
friend class SnapshotWriter;
friend class String;
friend class WeakProperty; // StorePointer
friend class Instance; // StorePointer
friend class StackFrame; // GetCodeObject assertion.
friend class CodeLookupTableBuilder; // profiler
friend class Interpreter;
friend class InterpreterHelpers;
friend class Simulator;
friend class SimulatorHelpers;
friend class ObjectLocator;
friend class WriteBarrierUpdateVisitor; // CheckHeapPointerStore
friend class OffsetsTable;
friend class Object;
DISALLOW_ALLOCATION();
DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectLayout);
};
inline intptr_t ObjectPtr::GetClassId() const {
return ptr()->GetClassId();
}
class ClassLayout : public ObjectLayout {
public:
enum ClassFinalizedState {
kAllocated = 0, // Initial state.
kPreFinalized, // VM classes: size precomputed, but no checks done.
kFinalized, // Class parsed, code compiled, not ready for allocation.
kAllocateFinalized, // CHA invalidated, class is ready for allocation.
};
enum ClassLoadingState {
// Class object is created, but it is not filled up.
// At this state class can only be used as a forward reference during
// class loading.
kNameOnly = 0,
// Class declaration information such as type parameters, supertype and
// implemented interfaces are loaded. However, types in the class are
// not finalized yet.
kDeclarationLoaded,
// Types in the class are finalized. At this point, members can be loaded
// and class can be finalized.
kTypeFinalized,
};
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(Class);
VISIT_FROM(ObjectPtr, name_);
StringPtr name_;
StringPtr user_name_;
ArrayPtr functions_;
ArrayPtr functions_hash_table_;
ArrayPtr fields_;
ArrayPtr offset_in_words_to_field_;
ArrayPtr interfaces_; // Array of AbstractType.
ScriptPtr script_;
LibraryPtr library_;
TypeArgumentsPtr type_parameters_; // Array of TypeParameter.
AbstractTypePtr super_type_;
FunctionPtr signature_function_; // Associated function for typedef class.
ArrayPtr constants_; // Canonicalized const instances of this class.
TypePtr declaration_type_; // Declaration type for this class.
ArrayPtr invocation_dispatcher_cache_; // Cache for dispatcher functions.
CodePtr allocation_stub_; // Stub code for allocation of instances.
GrowableObjectArrayPtr direct_implementors_; // Array of Class.
GrowableObjectArrayPtr direct_subclasses_; // Array of Class.
ArrayPtr dependent_code_; // CHA optimized codes.
VISIT_TO(ObjectPtr, dependent_code_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&allocation_stub_);
case Snapshot::kFull:
case Snapshot::kFullCore:
return reinterpret_cast<ObjectPtr*>(&direct_subclasses_);
case Snapshot::kFullJIT:
return reinterpret_cast<ObjectPtr*>(&dependent_code_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
TokenPosition token_pos_;
TokenPosition end_token_pos_;
classid_t id_; // Class Id, also index in the class table.
int16_t num_type_arguments_; // Number of type arguments in flattened vector.
uint16_t num_native_fields_;
uint32_t state_bits_;
// Size if fixed len or 0 if variable len.
int32_t host_instance_size_in_words_;
// Offset of type args fld.
int32_t host_type_arguments_field_offset_in_words_;
// Offset of the next instance field.
int32_t host_next_field_offset_in_words_;
#if !defined(DART_PRECOMPILED_RUNTIME)
// Size if fixed len or 0 if variable len (target).
int32_t target_instance_size_in_words_;
// Offset of type args fld.
int32_t target_type_arguments_field_offset_in_words_;
// Offset of the next instance field (target).
int32_t target_next_field_offset_in_words_;
#endif // !defined(DART_PRECOMPILED_RUNTIME)
#if !defined(DART_PRECOMPILED_RUNTIME)
typedef BitField<uint32_t, bool, 0, 1> IsDeclaredInBytecode;
typedef BitField<uint32_t, uint32_t, 1, 31> BinaryDeclarationOffset;
uint32_t binary_declaration_;
#endif // !defined(DART_PRECOMPILED_RUNTIME)
friend class Instance;
friend class Isolate;
friend class Object;
friend class InstanceLayout;
friend class InstructionsLayout;
friend class TypeArgumentsLayout;
friend class SnapshotReader;
friend class InstanceSerializationCluster;
friend class CidRewriteVisitor;
friend class Api;
};
class PatchClassLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(PatchClass);
VISIT_FROM(ObjectPtr, patched_class_);
ClassPtr patched_class_;
ClassPtr origin_class_;
ScriptPtr script_;
ExternalTypedDataPtr library_kernel_data_;
VISIT_TO(ObjectPtr, library_kernel_data_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&script_);
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
return reinterpret_cast<ObjectPtr*>(&library_kernel_data_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
NOT_IN_PRECOMPILED(intptr_t library_kernel_offset_);
friend class Function;
};
class FunctionLayout : public ObjectLayout {
public:
// When you add a new kind, please also update the observatory to account
// for the new string returned by KindToCString().
// - runtime/observatory/lib/src/models/objects/function.dart (FunctionKind)
// - runtime/observatory/lib/src/elements/function_view.dart
// (_functionKindToString)
// - runtime/observatory/lib/src/service/object.dart (stringToFunctionKind)
#define FOR_EACH_RAW_FUNCTION_KIND(V) \
/* an ordinary or operator method */ \
V(RegularFunction) \
/* a user-declared closure function */ \
V(ClosureFunction) \
/* an implicit closure (i.e., tear-off) */ \
V(ImplicitClosureFunction) \
/* a signature only without actual code */ \
V(SignatureFunction) \
/* getter functions e.g: get foo() { .. } */ \
V(GetterFunction) \
/* setter functions e.g: set foo(..) { .. } */ \
V(SetterFunction) \
/* a generative (is_static=false) or factory (is_static=true) constructor */ \
V(Constructor) \
/* an implicit getter for instance fields */ \
V(ImplicitGetter) \
/* an implicit setter for instance fields */ \
V(ImplicitSetter) \
/* represents an implicit getter for static fields with initializers */ \
V(ImplicitStaticGetter) \
/* the initialization expression for a static or instance field */ \
V(FieldInitializer) \
/* return a closure on the receiver for tear-offs */ \
V(MethodExtractor) \
/* builds an Invocation and invokes noSuchMethod */ \
V(NoSuchMethodDispatcher) \
/* invokes a field as a closure (i.e., call-through-getter) */ \
V(InvokeFieldDispatcher) \
/* a generated irregexp matcher function. */ \
V(IrregexpFunction) \
/* a forwarder which performs type checks for arguments of a dynamic call */ \
/* (i.e., those checks omitted by the caller for interface calls). */ \
V(DynamicInvocationForwarder) \
V(FfiTrampoline)
enum Kind {
#define KIND_DEFN(Name) k##Name,
FOR_EACH_RAW_FUNCTION_KIND(KIND_DEFN)
#undef KIND_DEFN
};
static const char* KindToCString(Kind k) {
switch (k) {
#define KIND_CASE(Name) \
case Kind::k##Name: \
return #Name;
FOR_EACH_RAW_FUNCTION_KIND(KIND_CASE)
#undef KIND_CASE
default:
UNREACHABLE();
return nullptr;
}
}
static bool ParseKind(const char* str, Kind* out) {
#define KIND_CASE(Name) \
if (strcmp(str, #Name) == 0) { \
*out = Kind::k##Name; \
return true; \
}
FOR_EACH_RAW_FUNCTION_KIND(KIND_CASE)
#undef KIND_CASE
return false;
}
enum AsyncModifier {
kNoModifier = 0x0,
kAsyncBit = 0x1,
kGeneratorBit = 0x2,
kAsync = kAsyncBit,
kSyncGen = kGeneratorBit,
kAsyncGen = kAsyncBit | kGeneratorBit,
};
// Wraps a 64-bit integer to represent the bitmap for unboxed parameters and
// return value. Two bits are used for each of them - the first one indicates
// whether this value is unboxed or not, and the second one says whether it is
// an integer or a double. It includes the two bits for the receiver, even
// though currently we do not have information from TFA that allows the
// receiver to be unboxed.
class UnboxedParameterBitmap {
public:
static constexpr intptr_t kBitsPerParameter = 2;
static constexpr intptr_t kParameterBitmask = (1 << kBitsPerParameter) - 1;
static constexpr intptr_t kCapacity =
(kBitsPerByte * sizeof(uint64_t)) / kBitsPerParameter;
UnboxedParameterBitmap() : bitmap_(0) {}
explicit UnboxedParameterBitmap(uint64_t bitmap) : bitmap_(bitmap) {}
UnboxedParameterBitmap(const UnboxedParameterBitmap&) = default;
UnboxedParameterBitmap& operator=(const UnboxedParameterBitmap&) = default;
DART_FORCE_INLINE bool IsUnboxed(intptr_t position) const {
if (position >= kCapacity) {
return false;
}
ASSERT(Utils::TestBit(bitmap_, kBitsPerParameter * position) ||
!Utils::TestBit(bitmap_, kBitsPerParameter * position + 1));
return Utils::TestBit(bitmap_, kBitsPerParameter * position);
}
DART_FORCE_INLINE bool IsUnboxedInteger(intptr_t position) const {
if (position >= kCapacity) {
return false;
}
return Utils::TestBit(bitmap_, kBitsPerParameter * position) &&
!Utils::TestBit(bitmap_, kBitsPerParameter * position + 1);
}
DART_FORCE_INLINE bool IsUnboxedDouble(intptr_t position) const {
if (position >= kCapacity) {
return false;
}
return Utils::TestBit(bitmap_, kBitsPerParameter * position) &&
Utils::TestBit(bitmap_, kBitsPerParameter * position + 1);
}
DART_FORCE_INLINE void SetUnboxedInteger(intptr_t position) {
ASSERT(position < kCapacity);
bitmap_ |= Utils::Bit<decltype(bitmap_)>(kBitsPerParameter * position);
ASSERT(!Utils::TestBit(bitmap_, kBitsPerParameter * position + 1));
}
DART_FORCE_INLINE void SetUnboxedDouble(intptr_t position) {
ASSERT(position < kCapacity);
bitmap_ |= Utils::Bit<decltype(bitmap_)>(kBitsPerParameter * position);
bitmap_ |=
Utils::Bit<decltype(bitmap_)>(kBitsPerParameter * position + 1);
}
DART_FORCE_INLINE uint64_t Value() const { return bitmap_; }
DART_FORCE_INLINE bool IsEmpty() const { return bitmap_ == 0; }
DART_FORCE_INLINE void Reset() { bitmap_ = 0; }
DART_FORCE_INLINE bool HasUnboxedParameters() const {
return (bitmap_ >> kBitsPerParameter) != 0;
}
DART_FORCE_INLINE bool HasUnboxedReturnValue() const {
return (bitmap_ & kParameterBitmask) != 0;
}
private:
uint64_t bitmap_;
};
static constexpr intptr_t kMaxFixedParametersBits = 14;
static constexpr intptr_t kMaxOptionalParametersBits = 13;
private:
friend class Class;
friend class UnitDeserializationRoots;
RAW_HEAP_OBJECT_IMPLEMENTATION(Function);
uword entry_point_; // Accessed from generated code.
uword unchecked_entry_point_; // Accessed from generated code.
VISIT_FROM(ObjectPtr, name_);
StringPtr name_;
ObjectPtr owner_; // Class or patch class or mixin class
// where this function is defined.
AbstractTypePtr result_type_;
ArrayPtr parameter_types_;
ArrayPtr parameter_names_;
TypeArgumentsPtr type_parameters_; // Array of TypeParameter.
ObjectPtr data_; // Additional data specific to the function kind. See
// Function::set_data() for details.
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
return reinterpret_cast<ObjectPtr*>(&data_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
ArrayPtr ic_data_array_; // ICData of unoptimized code.
ObjectPtr* to_no_code() {
return reinterpret_cast<ObjectPtr*>(&ic_data_array_);
}
CodePtr code_; // Currently active code. Accessed from generated code.
NOT_IN_PRECOMPILED(BytecodePtr bytecode_);
NOT_IN_PRECOMPILED(CodePtr unoptimized_code_); // Unoptimized code, keep it
// after optimization.
#if defined(DART_PRECOMPILED_RUNTIME)
VISIT_TO(ObjectPtr, code_);
#else
VISIT_TO(ObjectPtr, unoptimized_code_);
#endif
NOT_IN_PRECOMPILED(TokenPosition token_pos_);
NOT_IN_PRECOMPILED(TokenPosition end_token_pos_);
uint32_t kind_tag_; // See Function::KindTagBits.
uint32_t packed_fields_;
typedef BitField<uint32_t, bool, 0, 1> PackedHasNamedOptionalParameters;
typedef BitField<uint32_t,
bool,
PackedHasNamedOptionalParameters::kNextBit,
1>
OptimizableBit;
typedef BitField<uint32_t, bool, OptimizableBit::kNextBit, 1>
BackgroundOptimizableBit;
typedef BitField<uint32_t,
uint16_t,
BackgroundOptimizableBit::kNextBit,
kMaxFixedParametersBits>
PackedNumFixedParameters;
typedef BitField<uint32_t,
uint16_t,
PackedNumFixedParameters::kNextBit,
kMaxOptionalParametersBits>
PackedNumOptionalParameters;
static_assert(PackedNumOptionalParameters::kNextBit <=
kBitsPerWord * sizeof(decltype(packed_fields_)),
"FunctionLayout::packed_fields_ bitfields don't align.");
static_assert(PackedNumOptionalParameters::kNextBit <=
compiler::target::kSmiBits,
"In-place mask for number of optional parameters cannot fit in "
"a Smi on the target architecture");
#define JIT_FUNCTION_COUNTERS(F) \
F(intptr_t, int32_t, usage_counter) \
F(intptr_t, uint16_t, optimized_instruction_count) \
F(intptr_t, uint16_t, optimized_call_site_count) \
F(int8_t, int8_t, deoptimization_counter) \
F(intptr_t, int8_t, state_bits) \
F(int, int8_t, inlining_depth)
#if !defined(DART_PRECOMPILED_RUNTIME)
typedef BitField<uint32_t, bool, 0, 1> IsDeclaredInBytecode;
typedef BitField<uint32_t, uint32_t, 1, 31> BinaryDeclarationOffset;
uint32_t binary_declaration_;
#define DECLARE(return_type, type, name) type name##_;
JIT_FUNCTION_COUNTERS(DECLARE)
#undef DECLARE
#endif // !defined(DART_PRECOMPILED_RUNTIME)
NOT_IN_PRECOMPILED(UnboxedParameterBitmap unboxed_parameters_info_);
};
class ClosureDataLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(ClosureData);
VISIT_FROM(ObjectPtr, context_scope_);
ContextScopePtr context_scope_;
FunctionPtr parent_function_; // Enclosing function of this local function.
TypePtr signature_type_;
InstancePtr closure_; // Closure object for static implicit closures.
VISIT_TO(ObjectPtr, closure_);
friend class Function;
};
class SignatureDataLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(SignatureData);
VISIT_FROM(ObjectPtr, parent_function_);
FunctionPtr parent_function_; // Enclosing function of this sig. function.
TypePtr signature_type_;
VISIT_TO(ObjectPtr, signature_type_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
friend class Function;
};
class RedirectionDataLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(RedirectionData);
VISIT_FROM(ObjectPtr, type_);
TypePtr type_;
StringPtr identifier_;
FunctionPtr target_;
VISIT_TO(ObjectPtr, target_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
class FfiTrampolineDataLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(FfiTrampolineData);
VISIT_FROM(ObjectPtr, signature_type_);
TypePtr signature_type_;
FunctionPtr c_signature_;
// Target Dart method for callbacks, otherwise null.
FunctionPtr callback_target_;
// For callbacks, value to return if Dart target throws an exception.
InstancePtr callback_exceptional_return_;
VISIT_TO(ObjectPtr, callback_exceptional_return_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
// Callback id for callbacks.
//
// The callbacks ids are used so that native callbacks can lookup their own
// code objects, since native code doesn't pass code objects into function
// calls. The callback id is also used to for verifying that callbacks are
// called on the correct isolate. See DLRT_VerifyCallbackIsolate for details.
//
// Will be 0 for non-callbacks. Check 'callback_target_' to determine if this
// is a callback or not.
uint32_t callback_id_;
};
class FieldLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Field);
VISIT_FROM(ObjectPtr, name_);
StringPtr name_;
ObjectPtr owner_; // Class or patch class or mixin class
// where this field is defined or original field.
AbstractTypePtr type_;
FunctionPtr initializer_function_; // Static initializer function.
// - for instance fields: offset in words to the value in the class instance.
// - for static fields: index into field_table.
SmiPtr host_offset_or_field_id_;
// When generating APPJIT snapshots after running the application it is
// necessary to save the initial value of static fields so that we can
// restore the value back to the original initial value.
NOT_IN_PRECOMPILED(InstancePtr saved_initial_value_); // Saved initial value
SmiPtr guarded_list_length_;
ArrayPtr dependent_code_;
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&initializer_function_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
#if defined(DART_PRECOMPILED_RUNTIME)
VISIT_TO(ObjectPtr, dependent_code_);
#else
SubtypeTestCachePtr type_test_cache_; // For type test in implicit setter.
VISIT_TO(ObjectPtr, type_test_cache_);
#endif
TokenPosition token_pos_;
TokenPosition end_token_pos_;
ClassIdTagType guarded_cid_;
ClassIdTagType is_nullable_; // kNullCid if field can contain null value and
// kInvalidCid otherwise.
#if !defined(DART_PRECOMPILED_RUNTIME)
typedef BitField<uint32_t, bool, 0, 1> IsDeclaredInBytecode;
typedef BitField<uint32_t, uint32_t, 1, 31> BinaryDeclarationOffset;
uint32_t binary_declaration_;
#endif // !defined(DART_PRECOMPILED_RUNTIME)
// Offset to the guarded length field inside an instance of class matching
// guarded_cid_. Stored corrected by -kHeapObjectTag to simplify code
// generated on platforms with weak addressing modes (ARM).
int8_t guarded_list_length_in_object_offset_;
// Runtime tracking state of exactness of type annotation of this field.
// See StaticTypeExactnessState for the meaning and possible values in this
// field.
int8_t static_type_exactness_state_;
uint16_t kind_bits_; // static, final, const, has initializer....
#if !defined(DART_PRECOMPILED_RUNTIME)
// for instance fields, the offset in words in the target architecture
int32_t target_offset_;
#endif // !defined(DART_PRECOMPILED_RUNTIME)
friend class CidRewriteVisitor;
friend class GuardFieldClassInstr; // For sizeof(guarded_cid_/...)
friend class LoadFieldInstr; // For sizeof(guarded_cid_/...)
friend class StoreInstanceFieldInstr; // For sizeof(guarded_cid_/...)
};
class ScriptLayout : public ObjectLayout {
public:
enum {
kLazyLookupSourceAndLineStartsPos = 0,
kLazyLookupSourceAndLineStartsSize = 1,
};
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(Script);
VISIT_FROM(ObjectPtr, url_);
StringPtr url_;
StringPtr resolved_url_;
ArrayPtr compile_time_constants_;
TypedDataPtr line_starts_;
ArrayPtr debug_positions_;
KernelProgramInfoPtr kernel_program_info_;
StringPtr source_;
VISIT_TO(ObjectPtr, source_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&url_);
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
return reinterpret_cast<ObjectPtr*>(&kernel_program_info_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
int32_t line_offset_;
int32_t col_offset_;
using LazyLookupSourceAndLineStartsBit =
BitField<uint8_t,
bool,
kLazyLookupSourceAndLineStartsPos,
kLazyLookupSourceAndLineStartsSize>;
uint8_t flags_;
intptr_t kernel_script_index_;
int64_t load_timestamp_;
};
class LibraryLayout : public ObjectLayout {
enum LibraryState {
kAllocated, // Initial state.
kLoadRequested, // Compiler or script requested load of library.
kLoadInProgress, // Library is in the process of being loaded.
kLoaded, // Library is loaded.
};
enum LibraryFlags {
kDartSchemeBit = 0,
kDebuggableBit, // True if debugger can stop in library.
kInFullSnapshotBit, // True if library is in a full snapshot.
kNnbdBit, // True if library is non nullable by default.
kNnbdCompiledModePos, // Encodes nnbd compiled mode of constants in lib.
kNnbdCompiledModeSize = 2,
kNumFlagBits = kNnbdCompiledModePos + kNnbdCompiledModeSize,
};
COMPILE_ASSERT(kNumFlagBits <= (sizeof(uint8_t) * kBitsPerByte));
class DartSchemeBit : public BitField<uint8_t, bool, kDartSchemeBit, 1> {};
class DebuggableBit : public BitField<uint8_t, bool, kDebuggableBit, 1> {};
class InFullSnapshotBit
: public BitField<uint8_t, bool, kInFullSnapshotBit, 1> {};
class NnbdBit : public BitField<uint8_t, bool, kNnbdBit, 1> {};
class NnbdCompiledModeBits : public BitField<uint8_t,
uint8_t,
kNnbdCompiledModePos,
kNnbdCompiledModeSize> {};
RAW_HEAP_OBJECT_IMPLEMENTATION(Library);
VISIT_FROM(ObjectPtr, name_);
StringPtr name_;
StringPtr url_;
StringPtr private_key_;
ArrayPtr dictionary_; // Top-level names in this library.
GrowableObjectArrayPtr metadata_; // Metadata on classes, methods etc.
ClassPtr toplevel_class_; // Class containing top-level elements.
GrowableObjectArrayPtr used_scripts_;
LoadingUnitPtr loading_unit_;
ArrayPtr imports_; // List of Namespaces imported without prefix.
ArrayPtr exports_; // List of re-exported Namespaces.
ArrayPtr dependencies_;
ExternalTypedDataPtr kernel_data_;
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&exports_);
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
return reinterpret_cast<ObjectPtr*>(&kernel_data_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
ArrayPtr resolved_names_; // Cache of resolved names in library scope.
ArrayPtr exported_names_; // Cache of exported names by library.
ArrayPtr loaded_scripts_; // Array of scripts loaded in this library.
VISIT_TO(ObjectPtr, loaded_scripts_);
Dart_NativeEntryResolver native_entry_resolver_; // Resolves natives.
Dart_NativeEntrySymbol native_entry_symbol_resolver_;
classid_t index_; // Library id number.
uint16_t num_imports_; // Number of entries in imports_.
int8_t load_state_; // Of type LibraryState.
uint8_t flags_; // BitField for LibraryFlags.
#if !defined(DART_PRECOMPILED_RUNTIME)
typedef BitField<uint32_t, bool, 0, 1> IsDeclaredInBytecode;
typedef BitField<uint32_t, uint32_t, 1, 31> BinaryDeclarationOffset;
uint32_t binary_declaration_;
#endif // !defined(DART_PRECOMPILED_RUNTIME)
friend class Class;
friend class Isolate;
};
class NamespaceLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Namespace);
VISIT_FROM(ObjectPtr, library_);
LibraryPtr library_; // library with name dictionary.
ArrayPtr show_names_; // list of names that are exported.
ArrayPtr hide_names_; // list of names that are hidden.
FieldPtr metadata_field_; // remembers the token pos of metadata if any,
// and the metadata values if computed.
VISIT_TO(ObjectPtr, metadata_field_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
class KernelProgramInfoLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(KernelProgramInfo);
VISIT_FROM(ObjectPtr, string_offsets_);
TypedDataPtr string_offsets_;
ExternalTypedDataPtr string_data_;
TypedDataPtr canonical_names_;
ExternalTypedDataPtr metadata_payloads_;
ExternalTypedDataPtr metadata_mappings_;
ArrayPtr scripts_;
ArrayPtr constants_;
ArrayPtr bytecode_component_;
GrowableObjectArrayPtr potential_natives_;
GrowableObjectArrayPtr potential_pragma_functions_;
ExternalTypedDataPtr constants_table_;
ArrayPtr libraries_cache_;
ArrayPtr classes_cache_;
ObjectPtr retained_kernel_blob_;
VISIT_TO(ObjectPtr, retained_kernel_blob_);
uint32_t kernel_binary_version_;
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
return reinterpret_cast<ObjectPtr*>(&constants_table_);
}
};
class WeakSerializationReferenceLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(WeakSerializationReference);
#if defined(DART_PRECOMPILED_RUNTIME)
VISIT_NOTHING();
ClassIdTagType cid_;
#else
VISIT_FROM(ObjectPtr, target_);
ObjectPtr target_;
VISIT_TO(ObjectPtr, target_);
#endif
};
class CodeLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Code);
// When in the precompiled runtime, there is no disabling of Code objects
// and thus no active_instructions_ field. Thus, the entry point caches are
// only set once during deserialization. If not using bare instructions,
// the caches should match the entry points for instructions_.
//
// Otherwise, they should contain entry points for active_instructions_.
uword entry_point_; // Accessed from generated code.
// In AOT this entry-point supports switchable calls. It checks the type of
// the receiver on entry to the function and calls a stub to patch up the
// caller if they mismatch.
uword monomorphic_entry_point_; // Accessed from generated code (AOT only).
// Entry-point used from call-sites with some additional static information.
// The exact behavior of this entry-point depends on the kind of function:
//
// kRegularFunction/kSetter/kGetter:
//
// Call-site is assumed to know that the (type) arguments are invariantly
// type-correct against the actual runtime-type of the receiver. For
// instance, this entry-point is used for invocations against "this" and
// invocations from IC stubs that test the class type arguments.
//
// kClosureFunction:
//
// Call-site is assumed to pass the correct number of positional and type
// arguments (except in the case of partial instantiation, when the type
// arguments are omitted). All (type) arguments are assumed to match the
// corresponding (type) parameter types (bounds).
//
// kImplicitClosureFunction:
//
// Similar to kClosureFunction, except that the types (bounds) of the (type)
// arguments are expected to match the *runtime signature* of the closure,
// which (unlike with kClosureFunction) may have more general (type)
// parameter types (bounds) than the declared type of the forwarded method.
//
// In many cases a distinct static entry-point will not be created for a
// function if it would not be able to skip a lot of work (e.g., no argument
// type checks are necessary or this Code belongs to a stub). In this case
// 'unchecked_entry_point_' will refer to the same position as 'entry_point_'.
//
uword unchecked_entry_point_; // Accessed from generated code.
uword monomorphic_unchecked_entry_point_; // Accessed from generated code.
VISIT_FROM(ObjectPtr, object_pool_);
ObjectPoolPtr object_pool_; // Accessed from generated code.
InstructionsPtr instructions_; // Accessed from generated code.
// If owner_ is Function::null() the owner is a regular stub.
// If owner_ is a Class the owner is the allocation stub for that class.
// Else, owner_ is a regular Dart Function.
ObjectPtr owner_; // Function, Null, or a Class.
ExceptionHandlersPtr exception_handlers_;
PcDescriptorsPtr pc_descriptors_;
// If FLAG_precompiled_mode, then this field contains
// TypedDataPtr catch_entry_moves_maps
// Otherwise, it is
// SmiPtr num_variables
ObjectPtr catch_entry_;
CompressedStackMapsPtr compressed_stackmaps_;
ArrayPtr inlined_id_to_function_;
CodeSourceMapPtr code_source_map_;
NOT_IN_PRECOMPILED(InstructionsPtr active_instructions_);
NOT_IN_PRECOMPILED(ArrayPtr deopt_info_array_);
// (code-offset, function, code) triples.
NOT_IN_PRECOMPILED(ArrayPtr static_calls_target_table_);
// If return_address_metadata_ is a Smi, it is the offset to the prologue.
// Else, return_address_metadata_ is null.
NOT_IN_PRODUCT(ObjectPtr return_address_metadata_);
NOT_IN_PRODUCT(LocalVarDescriptorsPtr var_descriptors_);
NOT_IN_PRODUCT(ArrayPtr comments_);
#if !defined(PRODUCT)
VISIT_TO(ObjectPtr, comments_);
#elif defined(DART_PRECOMPILED_RUNTIME)
VISIT_TO(ObjectPtr, code_source_map_);
#else
VISIT_TO(ObjectPtr, static_calls_target_table_);
#endif
// Compilation timestamp.
NOT_IN_PRODUCT(alignas(8) int64_t compile_timestamp_);
// state_bits_ is a bitfield with three fields:
// The optimized bit, the alive bit, and a count of the number of pointer
// offsets.
// Alive: If true, the embedded object pointers will be visited during GC.
int32_t state_bits_;
// Caches the unchecked entry point offset for instructions_, in case we need
// to reset the active_instructions_ to instructions_.
NOT_IN_PRECOMPILED(uint32_t unchecked_offset_);
// Stores the instructions length when not using RawInstructions objects.
ONLY_IN_PRECOMPILED(uint32_t instructions_length_);
// Variable length data follows here.
int32_t* data() { OPEN_ARRAY_START(int32_t, int32_t); }
const int32_t* data() const { OPEN_ARRAY_START(int32_t, int32_t); }
static bool ContainsPC(const ObjectPtr raw_obj, uword pc);
friend class Function;
template <bool>
friend class MarkingVisitorBase;
friend class StackFrame;
friend class Profiler;
friend class FunctionDeserializationCluster;
friend class UnitSerializationRoots;
friend class UnitDeserializationRoots;
friend class CallSiteResetter;
};
class BytecodeLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Bytecode);
uword instructions_;
intptr_t instructions_size_;
VISIT_FROM(ObjectPtr, object_pool_);
ObjectPoolPtr object_pool_;
FunctionPtr function_;
ArrayPtr closures_;
ExceptionHandlersPtr exception_handlers_;
PcDescriptorsPtr pc_descriptors_;
NOT_IN_PRODUCT(LocalVarDescriptorsPtr var_descriptors_);
#if defined(PRODUCT)
VISIT_TO(ObjectPtr, pc_descriptors_);
#else
VISIT_TO(ObjectPtr, var_descriptors_);
#endif
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
return reinterpret_cast<ObjectPtr*>(&pc_descriptors_);
}
int32_t instructions_binary_offset_;
int32_t source_positions_binary_offset_;
int32_t local_variables_binary_offset_;
static bool ContainsPC(ObjectPtr raw_obj, uword pc);
friend class Function;
friend class StackFrame;
};
class ObjectPoolLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ObjectPool);
intptr_t length_;
struct Entry {
union {
ObjectPtr raw_obj_;
uword raw_value_;
};
};
Entry* data() { OPEN_ARRAY_START(Entry, Entry); }
Entry const* data() const { OPEN_ARRAY_START(Entry, Entry); }
// The entry bits are located after the last entry. They are encoded versions
// of `ObjectPool::TypeBits() | ObjectPool::PatchabililtyBit()`.
uint8_t* entry_bits() { return reinterpret_cast<uint8_t*>(&data()[length_]); }
uint8_t const* entry_bits() const {
return reinterpret_cast<uint8_t const*>(&data()[length_]);
}
friend class Object;
friend class CodeSerializationCluster;
};
class InstructionsLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Instructions);
VISIT_NOTHING();
// Instructions size in bytes and flags.
// Currently, only flag indicates 1 or 2 entry points.
uint32_t size_and_flags_;
// Variable length data follows here.
uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
// Private helper function used while visiting stack frames. The
// code which iterates over dart frames is also called during GC and
// is not allowed to create handles.
static bool ContainsPC(const InstructionsPtr raw_instr, uword pc);
friend class CodeLayout;
friend class FunctionLayout;
friend class Code;
friend class StackFrame;
template <bool>
friend class MarkingVisitorBase;
friend class Function;
friend class ImageReader;
friend class ImageWriter;
friend class AssemblyImageWriter;
friend class BlobImageWriter;
};
// Used to carry extra information to the VM without changing the embedder
// interface, to provide memory accounting for the bare instruction payloads
// we serialize, since they are no longer part of RawInstructions objects,
// and to avoid special casing bare instructions payload Images in the GC.
class InstructionsSectionLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(InstructionsSection);
VISIT_NOTHING();
// Instructions section payload length in bytes.
uword payload_length_;
// The offset of the corresponding BSS section from this text section.
word bss_offset_;
// The relocated address of this text section in the shared object. Properly
// filled for ELF snapshots, always 0 in assembly snapshots. (For the latter,
// we instead get the value during BSS initialization and store it there.)
uword instructions_relocated_address_;
// The offset of the GNU build ID note section from this text section.
word build_id_offset_;
// Variable length data follows here.
uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
friend class Image;
};
class PcDescriptorsLayout : public ObjectLayout {
public:
// The macro argument V is passed two arguments, the raw name of the enum value
// and the initialization expression used within the enum definition. The uses
// of enum values inside the initialization expression are hardcoded currently,
// so the second argument is useless outside the enum definition and should be
// dropped by other users of this macro.
#define FOR_EACH_RAW_PC_DESCRIPTOR(V) \
/* Deoptimization continuation point. */ \
V(Deopt, 1) \
/* IC call. */ \
V(IcCall, kDeopt << 1) \
/* Call to a known target via stub. */ \
V(UnoptStaticCall, kIcCall << 1) \
/* Runtime call. */ \
V(RuntimeCall, kUnoptStaticCall << 1) \
/* OSR entry point in unopt. code. */ \
V(OsrEntry, kRuntimeCall << 1) \
/* Call rewind target address. */ \
V(Rewind, kOsrEntry << 1) \
/* Target-word-size relocation. */ \
V(BSSRelocation, kRewind << 1) \
V(Other, kBSSRelocation << 1) \
V(AnyKind, -1)
enum Kind {
#define ENUM_DEF(name, init) k##name = init,
FOR_EACH_RAW_PC_DESCRIPTOR(ENUM_DEF)
#undef ENUM_DEF
kLastKind = kOther,
};
static const char* KindToCString(Kind k);
static bool ParseKind(const char* cstr, Kind* out);
// Used to represent the absense of a yield index in PcDescriptors.
static constexpr intptr_t kInvalidYieldIndex = -1;
class KindAndMetadata {
public:
// Most of the time try_index will be small and merged field will fit into
// one byte.
static uint32_t Encode(intptr_t kind,
intptr_t try_index,
intptr_t yield_index) {
return KindShiftBits::encode(Utils::ShiftForPowerOfTwo(kind)) |
TryIndexBits::encode(try_index + 1) |
YieldIndexBits::encode(yield_index + 1);
}
static intptr_t DecodeKind(uint32_t kind_and_metadata) {
return 1 << KindShiftBits::decode(kind_and_metadata);
}
static intptr_t DecodeTryIndex(uint32_t kind_and_metadata) {
return TryIndexBits::decode(kind_and_metadata) - 1;
}
static intptr_t DecodeYieldIndex(uint32_t kind_and_metadata) {
return YieldIndexBits::decode(kind_and_metadata) - 1;
}
private:
static const intptr_t kKindShiftSize = 3;
static const intptr_t kTryIndexSize = 10;
static const intptr_t kYieldIndexSize = 32 - kKindShiftSize - kTryIndexSize;
class KindShiftBits
: public BitField<uint32_t, intptr_t, 0, kKindShiftSize> {};
class TryIndexBits : public BitField<uint32_t,
intptr_t,
KindShiftBits::kNextBit,
kTryIndexSize> {};
class YieldIndexBits : public BitField<uint32_t,
intptr_t,
TryIndexBits::kNextBit,
kYieldIndexSize> {};
};
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors);
VISIT_NOTHING();
// Number of descriptors. This only needs to be an int32_t, but we make it a
// uword so that the variable length data is 64 bit aligned on 64 bit
// platforms.
uword length_;
// Variable length data follows here.
uint8_t* data() { OPEN_ARRAY_START(uint8_t, intptr_t); }
const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, intptr_t); }
friend class Object;
friend class ImageWriter;
};
// CodeSourceMap encodes a mapping from code PC ranges to source token
// positions and the stack of inlined functions.
class CodeSourceMapLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(CodeSourceMap);
VISIT_NOTHING();
// Length in bytes. This only needs to be an int32_t, but we make it a uword
// so that the variable length data is 64 bit aligned on 64 bit platforms.
uword length_;
// Variable length data follows here.
uint8_t* data() { OPEN_ARRAY_START(uint8_t, intptr_t); }
const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, intptr_t); }
friend class Object;
friend class ImageWriter;
};
// RawCompressedStackMaps is a compressed representation of the stack maps
// for certain PC offsets into a set of instructions, where a stack map is a bit
// map that marks each live object index starting from the base of the frame.
class CompressedStackMapsLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(CompressedStackMaps);
VISIT_NOTHING();
// The most significant bits are the length of the encoded payload, in bytes.
// The low bits determine the expected payload contents, as described below.
uint32_t flags_and_size_;
// Variable length data follows here. The contents of the payload depend on
// the type of CompressedStackMaps (CSM) being represented. There are three
// major types of CSM:
//
// 1) GlobalTableBit = false, UsesTableBit = false: CSMs that include all
// information about the stack maps. The payload for these contain tightly
// packed entries with the following information:
//
// * A header containing the following three pieces of information:
// * An unsigned integer representing the PC offset as a delta from the
// PC offset of the previous entry (from 0 for the first entry).
// * An unsigned integer representing the number of bits used for
// spill slot entries.
// * An unsigned integer representing the number of bits used for other
// entries.
// * The body containing the bits for the stack map. The length of the body
// in bits is the sum of the spill slot and non-spill slot bit counts.
//
// 2) GlobalTableBit = false, UsesTableBit = true: CSMs where the majority of
// the stack map information has been offloaded and canonicalized into a
// global table. The payload contains tightly packed entries with the
// following information:
//
// * A header containing just an unsigned integer representing the PC offset
// delta as described above.
// * The body is just an unsigned integer containing the offset into the
// payload for the global table.
//
// 3) GlobalTableBit = true, UsesTableBit = false: A CSM implementing the
// global table. Here, the payload contains tightly packed entries with
// the following information:
//
// * A header containing the following two pieces of information:
// * An unsigned integer representing the number of bits used for
// spill slot entries.
// * An unsigned integer representing the number of bits used for other
// entries.
// * The body containing the bits for the stack map. The length of the body
// in bits is the sum of the spill slot and non-spill slot bit counts.
//
// In all types of CSM, each unsigned integer is LEB128 encoded, as generally
// they tend to fit in a single byte or two. Thus, entry headers are not a
// fixed length, and currently there is no random access of entries. In
// addition, PC offsets are currently encoded as deltas, which also inhibits
// random access without accessing previous entries. That means to find an
// entry for a given PC offset, a linear search must be done where the payload
// is decoded up to the entry whose PC offset is >= the given PC.
uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
class GlobalTableBit : public BitField<uint32_t, bool, 0, 1> {};
class UsesTableBit
: public BitField<uint32_t, bool, GlobalTableBit::kNextBit, 1> {};
class SizeField : public BitField<uint32_t,
uint32_t,
UsesTableBit::kNextBit,
sizeof(flags_and_size_) * kBitsPerByte -
UsesTableBit::kNextBit> {};
friend class Object;
friend class ImageWriter;
friend class StackMapEntry;
};
class LocalVarDescriptorsLayout : public ObjectLayout {
public:
enum VarInfoKind {
kStackVar = 1,
kContextVar,
kContextLevel,
kSavedCurrentContext,
};
enum {
kKindPos = 0,
kKindSize = 8,
kIndexPos = kKindPos + kKindSize,
// Since there are 24 bits for the stack slot index, Functions can have
// only ~16.7 million stack slots.
kPayloadSize = sizeof(int32_t) * kBitsPerByte,
kIndexSize = kPayloadSize - kIndexPos,
kIndexBias = 1 << (kIndexSize - 1),
kMaxIndex = (1 << (kIndexSize - 1)) - 1,
};
class IndexBits : public BitField<int32_t, int32_t, kIndexPos, kIndexSize> {};
class KindBits : public BitField<int32_t, int8_t, kKindPos, kKindSize> {};
struct VarInfo {
int32_t index_kind; // Bitfield for slot index on stack or in context,
// and Entry kind of type VarInfoKind.
TokenPosition declaration_pos; // Token position of declaration.
TokenPosition begin_pos; // Token position of scope start.
TokenPosition end_pos; // Token position of scope end.
int16_t scope_id; // Scope to which the variable belongs.
VarInfoKind kind() const {
return static_cast<VarInfoKind>(KindBits::decode(index_kind));
}
void set_kind(VarInfoKind kind) {
index_kind = KindBits::update(kind, index_kind);
}
int32_t index() const { return IndexBits::decode(index_kind) - kIndexBias; }
void set_index(int32_t index) {
index_kind = IndexBits::update(index + kIndexBias, index_kind);
}
};
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(LocalVarDescriptors);
// Number of descriptors. This only needs to be an int32_t, but we make it a
// uword so that the variable length data is 64 bit aligned on 64 bit
// platforms.
uword num_entries_;
VISIT_FROM(ObjectPtr, names()[0]);
StringPtr* names() {
// Array of [num_entries_] variable names.
OPEN_ARRAY_START(StringPtr, StringPtr);
}
StringPtr* nameAddrAt(intptr_t i) { return &(names()[i]); }
VISIT_TO_LENGTH(ObjectPtr, nameAddrAt(length - 1));
// Variable info with [num_entries_] entries.
VarInfo* data() {
return reinterpret_cast<VarInfo*>(nameAddrAt(num_entries_));
}
friend class Object;
};
class ExceptionHandlersLayout : public ObjectLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(ExceptionHandlers);
// Number of exception handler entries.
int32_t num_entries_;
// Array with [num_entries_] entries. Each entry is an array of all handled
// exception types.
VISIT_FROM(ObjectPtr, handled_types_data_)
ArrayPtr handled_types_data_;
VISIT_TO_LENGTH(ObjectPtr, &handled_types_data_);
// Exception handler info of length [num_entries_].
const ExceptionHandlerInfo* data() const {
OPEN_ARRAY_START(ExceptionHandlerInfo, intptr_t);
}
ExceptionHandlerInfo* data() {
OPEN_ARRAY_START(ExceptionHandlerInfo, intptr_t);
}
friend class Object;
};
class ContextLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Context);
int32_t num_variables_;
VISIT_FROM(ObjectPtr, parent_);
ContextPtr parent_;
// Variable length data follows here.
ObjectPtr* data() { OPEN_ARRAY_START(ObjectPtr, ObjectPtr); }
ObjectPtr const* data() const { OPEN_ARRAY_START(ObjectPtr, ObjectPtr); }
VISIT_TO_LENGTH(ObjectPtr, &data()[length - 1]);
friend class Object;
friend class SnapshotReader;
};
class ContextScopeLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ContextScope);
// TODO(iposva): Switch to conventional enum offset based structure to avoid
// alignment mishaps.
struct VariableDesc {
SmiPtr declaration_token_pos;
SmiPtr token_pos;
StringPtr name;
SmiPtr flags;
static constexpr intptr_t kIsFinal = 0x1;
static constexpr intptr_t kIsConst = 0x2;
static constexpr intptr_t kIsLate = 0x4;
SmiPtr late_init_offset;
union {
AbstractTypePtr type;
InstancePtr value; // iff is_const is true
};
SmiPtr context_index;
SmiPtr context_level;
};
int32_t num_variables_;
bool is_implicit_; // true, if this context scope is for an implicit closure.
ObjectPtr* from() {
VariableDesc* begin = const_cast<VariableDesc*>(VariableDescAddr(0));
return reinterpret_cast<ObjectPtr*>(begin);
}
// Variable length data follows here.
ObjectPtr const* data() const { OPEN_ARRAY_START(ObjectPtr, ObjectPtr); }
const VariableDesc* VariableDescAddr(intptr_t index) const {
ASSERT((index >= 0) && (index < num_variables_ + 1));
// data() points to the first component of the first descriptor.
return &(reinterpret_cast<const VariableDesc*>(data())[index]);
}
ObjectPtr* to(intptr_t num_vars) {
uword end = reinterpret_cast<uword>(VariableDescAddr(num_vars));
// 'end' is the address just beyond the last descriptor, so step back.
return reinterpret_cast<ObjectPtr*>(end - kWordSize);
}
ObjectPtr* to_snapshot(Snapshot::Kind kind, intptr_t num_vars) {
return to(num_vars);
}
friend class Object;
friend class ClosureDataLayout;
friend class SnapshotReader;
};
class ParameterTypeCheckLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ParameterTypeCheck);
intptr_t index_;
VISIT_FROM(ObjectPtr, param_);
AbstractTypePtr param_;
AbstractTypePtr type_or_bound_;
StringPtr name_;
SubtypeTestCachePtr cache_;
VISIT_TO(ObjectPtr, cache_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
class SingleTargetCacheLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(SingleTargetCache);
VISIT_FROM(ObjectPtr, target_);
CodePtr target_;
VISIT_TO(ObjectPtr, target_);
uword entry_point_;
ClassIdTagType lower_limit_;
ClassIdTagType upper_limit_;
};
class MonomorphicSmiableCallLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(MonomorphicSmiableCall);
VISIT_FROM(ObjectPtr, target_);
CodePtr target_; // Entrypoint PC in bare mode, Code in non-bare mode.
VISIT_TO(ObjectPtr, target_);
uword expected_cid_;
uword entrypoint_;
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
// Abstract base class for RawICData/RawMegamorphicCache
class CallSiteDataLayout : public ObjectLayout {
protected:
StringPtr target_name_; // Name of target function.
// arg_descriptor in RawICData and in RawMegamorphicCache should be
// in the same position so that NoSuchMethod can access it.
ArrayPtr args_descriptor_; // Arguments descriptor.
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(CallSiteData)
};
class UnlinkedCallLayout : public CallSiteDataLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(UnlinkedCall);
VISIT_FROM(ObjectPtr, target_name_);
VISIT_TO(ObjectPtr, args_descriptor_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
bool can_patch_to_monomorphic_;
};
class ICDataLayout : public CallSiteDataLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ICData);
VISIT_FROM(ObjectPtr, target_name_);
ArrayPtr entries_; // Contains class-ids, target and count.
// Static type of the receiver, if instance call and available.
NOT_IN_PRECOMPILED(AbstractTypePtr receivers_static_type_);
ObjectPtr owner_; // Parent/calling function or original IC of cloned IC.
VISIT_TO(ObjectPtr, owner_);
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&entries_);
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
return to();
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
NOT_IN_PRECOMPILED(int32_t deopt_id_);
uint32_t state_bits_; // Number of arguments tested in IC, deopt reasons.
};
class MegamorphicCacheLayout : public CallSiteDataLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(MegamorphicCache);
VISIT_FROM(ObjectPtr, target_name_)
ArrayPtr buckets_;
SmiPtr mask_;
VISIT_TO(ObjectPtr, mask_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
int32_t filled_entry_count_;
};
class SubtypeTestCacheLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(SubtypeTestCache);
VISIT_FROM(ObjectPtr, cache_);
ArrayPtr cache_;
VISIT_TO(ObjectPtr, cache_);
};
class LoadingUnitLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(LoadingUnit);
VISIT_FROM(ObjectPtr, parent_);
LoadingUnitPtr parent_;
ArrayPtr base_objects_;
VISIT_TO(ObjectPtr, base_objects_);
int32_t id_;
bool load_outstanding_;
bool loaded_;
};
class ErrorLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Error);
};
class ApiErrorLayout : public ErrorLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ApiError);
VISIT_FROM(ObjectPtr, message_)
StringPtr message_;
VISIT_TO(ObjectPtr, message_)
};
class LanguageErrorLayout : public ErrorLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(LanguageError);
VISIT_FROM(ObjectPtr, previous_error_)
ErrorPtr previous_error_; // May be null.
ScriptPtr script_;
StringPtr message_;
StringPtr formatted_message_; // Incl. previous error's formatted message.
VISIT_TO(ObjectPtr, formatted_message_)
TokenPosition token_pos_; // Source position in script_.
bool report_after_token_; // Report message at or after the token.
int8_t kind_; // Of type Report::Kind.
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
class UnhandledExceptionLayout : public ErrorLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(UnhandledException);
VISIT_FROM(ObjectPtr, exception_)
InstancePtr exception_;
InstancePtr stacktrace_;
VISIT_TO(ObjectPtr, stacktrace_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
class UnwindErrorLayout : public ErrorLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(UnwindError);
VISIT_FROM(ObjectPtr, message_)
StringPtr message_;
VISIT_TO(ObjectPtr, message_)
bool is_user_initiated_;
};
class InstanceLayout : public ObjectLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Instance);
};
class LibraryPrefixLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix);
VISIT_FROM(ObjectPtr, name_)
StringPtr name_; // Library prefix name.
ArrayPtr imports_; // Libraries imported with this prefix.
LibraryPtr importer_; // Library which declares this prefix.
VISIT_TO(ObjectPtr, importer_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) {
switch (kind) {
case Snapshot::kFullAOT:
return reinterpret_cast<ObjectPtr*>(&imports_);
case Snapshot::kFull:
case Snapshot::kFullCore:
case Snapshot::kFullJIT:
return reinterpret_cast<ObjectPtr*>(&importer_);
case Snapshot::kMessage:
case Snapshot::kNone:
case Snapshot::kInvalid:
break;
}
UNREACHABLE();
return NULL;
}
uint16_t num_imports_; // Number of library entries in libraries_.
bool is_deferred_load_;
bool is_loaded_;
};
class TypeArgumentsLayout : public InstanceLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(TypeArguments);
VISIT_FROM(ObjectPtr, instantiations_)
// The instantiations_ array remains empty for instantiated type arguments.
ArrayPtr instantiations_; // Of 3-tuple: 2 instantiators, result.
SmiPtr length_;
SmiPtr hash_;
SmiPtr nullability_;
// Variable length data follows here.
AbstractTypePtr const* types() const {
OPEN_ARRAY_START(AbstractTypePtr, AbstractTypePtr);
}
AbstractTypePtr* types() {
OPEN_ARRAY_START(AbstractTypePtr, AbstractTypePtr);
}
ObjectPtr* to(intptr_t length) {
return reinterpret_cast<ObjectPtr*>(&types()[length - 1]);
}
friend class Object;
friend class SnapshotReader;
};
class AbstractTypeLayout : public InstanceLayout {
public:
enum TypeState {
kAllocated, // Initial state.
kBeingFinalized, // In the process of being finalized.
kFinalizedInstantiated, // Instantiated type ready for use.
kFinalizedUninstantiated, // Uninstantiated type ready for use.
// Adjust kTypeStateBitSize if more are added.
};
protected:
static constexpr intptr_t kTypeStateBitSize = 2;
uword type_test_stub_entry_point_; // Accessed from generated code.
CodePtr type_test_stub_; // Must be the last field, since subclasses use it
// in their VISIT_FROM.
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractType);
friend class ObjectStore;
friend class StubCode;
};
class TypeLayout : public AbstractTypeLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(Type);
VISIT_FROM(ObjectPtr, type_test_stub_)
SmiPtr type_class_id_;
TypeArgumentsPtr arguments_;
SmiPtr hash_;
// This type object represents a function type if its signature field is a
// non-null function object.
FunctionPtr signature_; // If not null, this type is a function type.
VISIT_TO(ObjectPtr, signature_)
TokenPosition token_pos_;
int8_t type_state_;
int8_t nullability_;
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
friend class CidRewriteVisitor;
friend class TypeArgumentsLayout;
};
class TypeRefLayout : public AbstractTypeLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(TypeRef);
VISIT_FROM(ObjectPtr, type_test_stub_)
AbstractTypePtr type_; // The referenced type.
VISIT_TO(ObjectPtr, type_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
};
class TypeParameterLayout : public AbstractTypeLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(TypeParameter);
VISIT_FROM(ObjectPtr, type_test_stub_)
StringPtr name_;
SmiPtr hash_;
AbstractTypePtr bound_; // ObjectType if no explicit bound specified.
FunctionPtr parameterized_function_;
VISIT_TO(ObjectPtr, parameterized_function_)
ClassIdTagType parameterized_class_id_;
TokenPosition token_pos_;
int16_t index_;
uint8_t flags_;
int8_t nullability_;
using FinalizedBit = BitField<decltype(flags_), bool, 0, 1>;
using GenericCovariantImplBit =
BitField<decltype(flags_), bool, FinalizedBit::kNextBit, 1>;
using DeclarationBit =
BitField<decltype(flags_), bool, GenericCovariantImplBit::kNextBit, 1>;
static constexpr intptr_t kFlagsBitSize = DeclarationBit::kNextBit;
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
friend class CidRewriteVisitor;
};
class ClosureLayout : public InstanceLayout {
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
// No instance fields should be declared before the following fields whose
// offsets must be identical in Dart and C++.
// The following fields are also declared in the Dart source of class
// _Closure.
VISIT_FROM(RawCompressed, instantiator_type_arguments_)
TypeArgumentsPtr instantiator_type_arguments_;
TypeArgumentsPtr function_type_arguments_;
TypeArgumentsPtr delayed_type_arguments_;
FunctionPtr function_;
ContextPtr context_;
SmiPtr hash_;
VISIT_TO(RawCompressed, hash_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
// Note that instantiator_type_arguments_, function_type_arguments_ and
// delayed_type_arguments_ are used to instantiate the signature of function_
// when this closure is involved in a type test. In other words, these fields
// define the function type of this closure instance.
//
// function_type_arguments_ and delayed_type_arguments_ may also be used when
// invoking the closure. Whereas the source frontend will save a copy of the
// function's type arguments in the closure's context and only use the
// function_type_arguments_ field for type tests, the kernel frontend will use
// the function_type_arguments_ vector here directly.
//
// If this closure is generic, it can be invoked with function type arguments
// that will be processed in the prolog of the closure function_. For example,
// if the generic closure function_ has a generic parent function, the
// passed-in function type arguments get concatenated to the function type
// arguments of the parent that are found in the context_.
//
// delayed_type_arguments_ is used to support the partial instantiation
// feature. When this field is set to any value other than
// Object::empty_type_arguments(), the types in this vector will be passed as
// type arguments to the closure when invoked. In this case there may not be
// any type arguments passed directly (or NSM will be invoked instead).
};
class NumberLayout : public InstanceLayout {
RAW_OBJECT_IMPLEMENTATION(Number);
};
class IntegerLayout : public NumberLayout {
RAW_OBJECT_IMPLEMENTATION(Integer);
};
class SmiLayout : public IntegerLayout {
RAW_OBJECT_IMPLEMENTATION(Smi);
};
class MintLayout : public IntegerLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Mint);
VISIT_NOTHING();
ALIGN8 int64_t value_;
friend class Api;
friend class Class;
friend class Integer;
friend class SnapshotReader;
};
COMPILE_ASSERT(sizeof(MintLayout) == 16);
class DoubleLayout : public NumberLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Double);
VISIT_NOTHING();
ALIGN8 double value_;
friend class Api;
friend class SnapshotReader;
friend class Class;
};
COMPILE_ASSERT(sizeof(DoubleLayout) == 16);
class StringLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(String);
protected:
VISIT_FROM(ObjectPtr, length_)
SmiPtr length_;
#if !defined(HASH_IN_OBJECT_HEADER)
SmiPtr hash_;
VISIT_TO(ObjectPtr, hash_)
#else
VISIT_TO(ObjectPtr, length_)
#endif
private:
friend class Library;
friend class OneByteStringSerializationCluster;
friend class TwoByteStringSerializationCluster;
friend class OneByteStringDeserializationCluster;
friend class TwoByteStringDeserializationCluster;
friend class RODataSerializationCluster;
friend class ImageWriter;
};
class OneByteStringLayout : public StringLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(OneByteString);
VISIT_NOTHING();
// Variable length data follows here.
uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
friend class ApiMessageReader;
friend class RODataSerializationCluster;
friend class SnapshotReader;
friend class String;
};
class TwoByteStringLayout : public StringLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(TwoByteString);
VISIT_NOTHING();
// Variable length data follows here.
uint16_t* data() { OPEN_ARRAY_START(uint16_t, uint16_t); }
const uint16_t* data() const { OPEN_ARRAY_START(uint16_t, uint16_t); }
friend class RODataSerializationCluster;
friend class SnapshotReader;
friend class String;
};
// Abstract base class for RawTypedData/RawExternalTypedData/RawTypedDataView/
// Pointer.
//
// TypedData extends this with a length field, while Pointer extends this with
// TypeArguments field.
class PointerBaseLayout : public InstanceLayout {
protected:
// The contents of [data_] depends on what concrete subclass is used:
//
// - RawTypedData: Start of the payload.
// - RawExternalTypedData: Start of the C-heap payload.
// - RawTypedDataView: The [data_] field of the backing store for the view
// plus the [offset_in_bytes_] the view has.
// - RawPointer: Pointer into C memory (no length specified).
//
// During allocation or snapshot reading the [data_] can be temporarily
// nullptr (which is the case for views which just got created but haven't
// gotten the backing store set).
uint8_t* data_;
private:
RAW_HEAP_OBJECT_IMPLEMENTATION(PointerBase);
};
// Abstract base class for RawTypedData/RawExternalTypedData/RawTypedDataView.
class TypedDataBaseLayout : public PointerBaseLayout {
protected:
// The length of the view in element sizes (obtainable via
// [TypedDataBase::ElementSizeInBytes]).
SmiPtr length_;
private:
friend class TypedDataViewLayout;
RAW_HEAP_OBJECT_IMPLEMENTATION(TypedDataBase);
};
class TypedDataLayout : public TypedDataBaseLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(TypedData);
public:
static intptr_t payload_offset() {
return OFFSET_OF_RETURNED_VALUE(TypedDataLayout, internal_data);
}
// Recompute [data_] pointer to internal data.
void RecomputeDataField() { data_ = internal_data(); }
protected:
VISIT_FROM(RawCompressed, length_)
VISIT_TO_LENGTH(RawCompressed, &length_)
// Variable length data follows here.
uint8_t* internal_data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
const uint8_t* internal_data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
uint8_t* data() {
ASSERT(data_ == internal_data());
return data_;
}
const uint8_t* data() const {
ASSERT(data_ == internal_data());
return data_;
}
friend class Api;
friend class Instance;
friend class NativeEntryData;
friend class Object;
friend class ObjectPool;
friend class ObjectPoolDeserializationCluster;
friend class ObjectPoolSerializationCluster;
friend class ObjectPoolLayout;
friend class SnapshotReader;
};
// All _*ArrayView/_ByteDataView classes share the same layout.
class TypedDataViewLayout : public TypedDataBaseLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(TypedDataView);
public:
// Recompute [data_] based on internal/external [typed_data_].
void RecomputeDataField() {
const intptr_t offset_in_bytes = RawSmiValue(offset_in_bytes_);
uint8_t* payload = typed_data_->ptr()->data_;
data_ = payload + offset_in_bytes;
}
// Recopute [data_] based on internal [typed_data_] - needs to be called by GC
// whenever the backing store moved.
//
// NOTICE: This method assumes [this] is the forwarded object and the
// [typed_data_] pointer points to the new backing store. The backing store's
// fields don't need to be valid - only it's address.
void RecomputeDataFieldForInternalTypedData() {
const intptr_t offset_in_bytes = RawSmiValue(offset_in_bytes_);
uint8_t* payload = reinterpret_cast<uint8_t*>(
ObjectLayout::ToAddr(typed_data_) + TypedDataLayout::payload_offset());
data_ = payload + offset_in_bytes;
}
void ValidateInnerPointer() {
if (typed_data_->ptr()->GetClassId() == kNullCid) {
// The view object must have gotten just initialized.
if (data_ != nullptr || RawSmiValue(offset_in_bytes_) != 0 ||
RawSmiValue(length_) != 0) {
FATAL("RawTypedDataView has invalid inner pointer.");
}
} else {
const intptr_t offset_in_bytes = RawSmiValue(offset_in_bytes_);
uint8_t* payload = typed_data_->ptr()->data_;
if ((payload + offset_in_bytes) != data_) {
FATAL("RawTypedDataView has invalid inner pointer.");
}
}
}
protected:
VISIT_FROM(ObjectPtr, length_)
TypedDataBasePtr typed_data_;
SmiPtr offset_in_bytes_;
VISIT_TO(ObjectPtr, offset_in_bytes_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
friend class Api;
friend class Object;
friend class ObjectPoolDeserializationCluster;
friend class ObjectPoolSerializationCluster;
friend class ObjectPoolLayout;
friend class GCCompactor;
template <bool>
friend class ScavengerVisitorBase;
friend class SnapshotReader;
};
class ExternalOneByteStringLayout : public StringLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalOneByteString);
const uint8_t* external_data_;
void* peer_;
friend class Api;
friend class String;
};
class ExternalTwoByteStringLayout : public StringLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalTwoByteString);
const uint16_t* external_data_;
void* peer_;
friend class Api;
friend class String;
};
class BoolLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Bool);
VISIT_NOTHING();
bool value_;
friend class Object;
};
class ArrayLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Array);
VISIT_FROM(RawCompressed, type_arguments_)
TypeArgumentsPtr type_arguments_;
SmiPtr length_;
// Variable length data follows here.
ObjectPtr* data() { OPEN_ARRAY_START(ObjectPtr, ObjectPtr); }
ObjectPtr const* data() const { OPEN_ARRAY_START(ObjectPtr, ObjectPtr); }
VISIT_TO_LENGTH(RawCompressed, &data()[length - 1])
friend class LinkedHashMapSerializationCluster;
friend class LinkedHashMapDeserializationCluster;
friend class CodeSerializationCluster;
friend class CodeDeserializationCluster;
friend class Deserializer;
friend class CodeLayout;
friend class ImmutableArrayLayout;
friend class SnapshotReader;
friend class GrowableObjectArray;
friend class LinkedHashMap;
friend class LinkedHashMapLayout;
friend class Object;
friend class ICData; // For high performance access.
friend class SubtypeTestCache; // For high performance access.
friend class ReversePc;
friend class OldPage;
};
class ImmutableArrayLayout : public ArrayLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ImmutableArray);
friend class SnapshotReader;
};
class GrowableObjectArrayLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray);
VISIT_FROM(RawCompressed, type_arguments_)
TypeArgumentsPtr type_arguments_;
SmiPtr length_;
ArrayPtr data_;
VISIT_TO(RawCompressed, data_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
friend class SnapshotReader;
friend class ReversePc;
};
class LinkedHashMapLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(LinkedHashMap);
VISIT_FROM(RawCompressed, type_arguments_)
TypeArgumentsPtr type_arguments_;
TypedDataPtr index_;
SmiPtr hash_mask_;
ArrayPtr data_;
SmiPtr used_data_;
SmiPtr deleted_keys_;
VISIT_TO(RawCompressed, deleted_keys_)
friend class SnapshotReader;
};
class Float32x4Layout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Float32x4);
VISIT_NOTHING();
ALIGN8 float value_[4];
friend class SnapshotReader;
friend class Class;
public:
float x() const { return value_[0]; }
float y() const { return value_[1]; }
float z() const { return value_[2]; }
float w() const { return value_[3]; }
};
COMPILE_ASSERT(sizeof(Float32x4Layout) == 24);
class Int32x4Layout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Int32x4);
VISIT_NOTHING();
ALIGN8 int32_t value_[4];
friend class SnapshotReader;
public:
int32_t x() const { return value_[0]; }
int32_t y() const { return value_[1]; }
int32_t z() const { return value_[2]; }
int32_t w() const { return value_[3]; }
};
COMPILE_ASSERT(sizeof(Int32x4Layout) == 24);
class Float64x2Layout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Float64x2);
VISIT_NOTHING();
ALIGN8 double value_[2];
friend class SnapshotReader;
friend class Class;
public:
double x() const { return value_[0]; }
double y() const { return value_[1]; }
};
COMPILE_ASSERT(sizeof(Float64x2Layout) == 24);
// Define an aliases for intptr_t.
#if defined(ARCH_IS_32_BIT)
#define kIntPtrCid kTypedDataInt32ArrayCid
#define SetIntPtr SetInt32
#elif defined(ARCH_IS_64_BIT)
#define kIntPtrCid kTypedDataInt64ArrayCid
#define SetIntPtr SetInt64
#else
#error Architecture is not 32-bit or 64-bit.
#endif // ARCH_IS_32_BIT
class ExternalTypedDataLayout : public TypedDataBaseLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData);
protected:
VISIT_FROM(RawCompressed, length_)
VISIT_TO(RawCompressed, length_)
friend class BytecodeLayout;
};
class PointerLayout : public PointerBaseLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Pointer);
VISIT_FROM(RawCompressed, type_arguments_)
TypeArgumentsPtr type_arguments_;
VISIT_TO(RawCompressed, type_arguments_)
friend class Pointer;
};
class DynamicLibraryLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(DynamicLibrary);
VISIT_NOTHING();
void* handle_;
friend class DynamicLibrary;
};
// VM implementations of the basic types in the isolate.
class alignas(8) CapabilityLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(Capability);
VISIT_NOTHING();
uint64_t id_;
};
class alignas(8) SendPortLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(SendPort);
VISIT_NOTHING();
Dart_Port id_;
Dart_Port origin_id_;
friend class ReceivePort;
};
class ReceivePortLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(ReceivePort);
VISIT_FROM(ObjectPtr, send_port_)
SendPortPtr send_port_;
InstancePtr handler_;
VISIT_TO(ObjectPtr, handler_)
};
class TransferableTypedDataLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(TransferableTypedData);
VISIT_NOTHING();
};
// VM type for capturing stacktraces when exceptions are thrown,
// Currently we don't have any interface that this object is supposed
// to implement so we just support the 'toString' method which
// converts the stack trace into a string.
class StackTraceLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(StackTrace);
VISIT_FROM(ObjectPtr, async_link_)
StackTracePtr async_link_; // Link to parent async stack trace.
ArrayPtr code_array_; // Code object for each frame in the stack trace.
ArrayPtr pc_offset_array_; // Offset of PC for each frame.
VISIT_TO(ObjectPtr, pc_offset_array_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
// False for pre-allocated stack trace (used in OOM and Stack overflow).
bool expand_inlined_;
// Whether the link between the stack and the async-link represents a
// synchronous start to an asynchronous function. In this case, we omit the
// <asynchronous suspension> marker when concatenating the stacks.
bool skip_sync_start_in_parent_stack;
};
// VM type for capturing JS regular expressions.
class RegExpLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(RegExp);
VISIT_FROM(ObjectPtr, num_bracket_expressions_)
SmiPtr num_bracket_expressions_;
ArrayPtr capture_name_map_;
StringPtr pattern_; // Pattern to be used for matching.
union {
FunctionPtr function_;
TypedDataPtr bytecode_;
} one_byte_;
union {
FunctionPtr function_;
TypedDataPtr bytecode_;
} two_byte_;
FunctionPtr external_one_byte_function_;
FunctionPtr external_two_byte_function_;
union {
FunctionPtr function_;
TypedDataPtr bytecode_;
} one_byte_sticky_;
union {
FunctionPtr function_;
TypedDataPtr bytecode_;
} two_byte_sticky_;
FunctionPtr external_one_byte_sticky_function_;
FunctionPtr external_two_byte_sticky_function_;
VISIT_TO(ObjectPtr, external_two_byte_sticky_function_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
// The same pattern may use different amount of registers if compiled
// for a one-byte target than a two-byte target. For example, we do not
// need to allocate registers to check whether the current position is within
// a surrogate pair when matching a Unicode pattern against a one-byte string.
intptr_t num_one_byte_registers_;
intptr_t num_two_byte_registers_;
// A bitfield with two fields:
// type: Uninitialized, simple or complex.
// flags: Represents global/local, case insensitive, multiline, unicode,
// dotAll.
int8_t type_flags_;
};
class WeakPropertyLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(WeakProperty);
VISIT_FROM(ObjectPtr, key_)
ObjectPtr key_;
ObjectPtr value_;
VISIT_TO(ObjectPtr, value_)
ObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); }
// Linked list is chaining all pending weak properties.
// Untyped to make it clear that it is not to be visited by GC.
uword next_;
friend class GCMarker;
template <bool>
friend class MarkingVisitorBase;
friend class Scavenger;
template <bool>
friend class ScavengerVisitorBase;
};
// MirrorReferences are used by mirrors to hold reflectees that are VM
// internal objects, such as libraries, classes, functions or types.
class MirrorReferenceLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(MirrorReference);
VISIT_FROM(ObjectPtr, referent_)
ObjectPtr referent_;
VISIT_TO(ObjectPtr, referent_)
};
// UserTag are used by the profiler to track Dart script state.
class UserTagLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(UserTag);
VISIT_FROM(ObjectPtr, label_)
StringPtr label_;
VISIT_TO(ObjectPtr, label_)
// Isolate unique tag.
uword tag_;
friend class SnapshotReader;
friend class Object;
public:
uword tag() const { return tag_; }
};
class FutureOrLayout : public InstanceLayout {
RAW_HEAP_OBJECT_IMPLEMENTATION(FutureOr);
VISIT_FROM(RawCompressed, type_arguments_)
TypeArgumentsPtr type_arguments_;
VISIT_TO(RawCompressed, type_arguments_)
friend class SnapshotReader;
};
} // namespace dart
#endif // RUNTIME_VM_RAW_OBJECT_H_
Reference in New Issue View Git Blame Copy Permalink