blob: c4592774d18e0d07b8970c5e72e89bb8878263a5 [file] [log] [blame] [edit]
// 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.
#include "vm/raw_object.h"
#include "vm/class_table.h"
#include "vm/dart.h"
#include "vm/heap/become.h"
#include "vm/heap/freelist.h"
#include "vm/isolate.h"
#include "vm/isolate_reload.h"
#include "vm/object.h"
#include "vm/runtime_entry.h"
#include "vm/stack_frame.h"
#include "vm/visitor.h"
namespace dart {
bool UntaggedObject::InVMIsolateHeap() const {
// All "vm-isolate" objects are pre-marked and in old space
// (see [Object::FinalizeVMIsolate]).
if (!IsOldObject() || !IsMarked()) return false;
auto heap = Dart::vm_isolate_group()->heap();
ASSERT(heap->UsedInWords(Heap::kNew) == 0);
return heap->old_space()->ContainsUnsafe(ToAddr(this));
}
void ObjectPtr::Validate(IsolateGroup* isolate_group) const {
// All Smi values are valid.
if (!IsHeapObject()) {
return;
}
// Slightly more readable than a segfault.
if (tagged_pointer_ == kHeapObjectTag) {
FATAL("RAW_NULL encountered");
}
untag()->Validate(isolate_group);
}
void UntaggedObject::Validate(IsolateGroup* isolate_group) const {
if (static_cast<uword>(Object::void_class_) == kHeapObjectTag) {
// Validation relies on properly initialized class classes. Skip if the
// VM is still being initialized.
return;
}
// Validate that the tags_ field is sensible.
uword tags = tags_;
if (IsNewObject()) {
if (!NewOrEvacuationCandidateBit::decode(tags)) {
FATAL("New object missing kNewBit: %" Px "\n", tags);
}
if (OldAndNotRememberedBit::decode(tags)) {
FATAL("New object has kOldAndNotRememberedBit: %" Px "\n", tags);
}
}
const intptr_t class_id = ClassIdTag::decode(tags);
if (!isolate_group->class_table()->IsValidIndex(class_id)) {
FATAL("Invalid class id encountered %" Pd "\n", class_id);
}
if (class_id == kNullCid &&
isolate_group->class_table()->HasValidClassAt(class_id)) {
// Null class not yet initialized; skip.
return;
}
intptr_t size_from_tags = SizeTag::decode(tags);
intptr_t size_from_class = HeapSizeFromClass(tags);
if ((size_from_tags != 0) && (size_from_tags != size_from_class)) {
FATAL(
"Inconsistent size encountered "
"cid: %" Pd ", size_from_tags: %" Pd ", size_from_class: %" Pd "\n",
class_id, size_from_tags, size_from_class);
}
}
// Can't look at the class object because it can be called during
// compaction when the class objects are moving. Can use the class
// id in the header and the sizes in the Class Table.
// Cannot deference ptr()->tags_. May dereference other parts of the object.
intptr_t UntaggedObject::HeapSizeFromClass(uword tags) const {
intptr_t class_id = ClassIdTag::decode(tags);
intptr_t instance_size = 0;
switch (class_id) {
case kCodeCid: {
const CodePtr raw_code = static_cast<const CodePtr>(this);
intptr_t pointer_offsets_length =
Code::PtrOffBits::decode(raw_code->untag()->state_bits_);
instance_size = Code::InstanceSize(pointer_offsets_length);
break;
}
case kInstructionsCid: {
const InstructionsPtr raw_instructions =
static_cast<const InstructionsPtr>(this);
intptr_t instructions_size = Instructions::Size(raw_instructions);
instance_size = Instructions::InstanceSize(instructions_size);
break;
}
case kInstructionsSectionCid: {
const InstructionsSectionPtr raw_section =
static_cast<const InstructionsSectionPtr>(this);
intptr_t section_size = InstructionsSection::Size(raw_section);
instance_size = InstructionsSection::InstanceSize(section_size);
break;
}
case kContextCid: {
const ContextPtr raw_context = static_cast<const ContextPtr>(this);
intptr_t num_variables = raw_context->untag()->num_variables_;
instance_size = Context::InstanceSize(num_variables);
break;
}
case kContextScopeCid: {
const ContextScopePtr raw_context_scope =
static_cast<const ContextScopePtr>(this);
intptr_t num_variables = raw_context_scope->untag()->num_variables_;
instance_size = ContextScope::InstanceSize(num_variables);
break;
}
case kOneByteStringCid: {
const OneByteStringPtr raw_string =
static_cast<const OneByteStringPtr>(this);
intptr_t string_length = Smi::Value(raw_string->untag()->length());
instance_size = OneByteString::InstanceSize(string_length);
break;
}
case kTwoByteStringCid: {
const TwoByteStringPtr raw_string =
static_cast<const TwoByteStringPtr>(this);
intptr_t string_length = Smi::Value(raw_string->untag()->length());
instance_size = TwoByteString::InstanceSize(string_length);
break;
}
case kArrayCid:
case kImmutableArrayCid: {
const ArrayPtr raw_array = static_cast<const ArrayPtr>(this);
intptr_t array_length =
Smi::Value(raw_array->untag()->length<std::memory_order_acquire>());
instance_size = Array::InstanceSize(array_length);
break;
}
case kWeakArrayCid: {
const WeakArrayPtr raw_array = static_cast<const WeakArrayPtr>(this);
intptr_t array_length = Smi::Value(raw_array->untag()->length());
instance_size = WeakArray::InstanceSize(array_length);
break;
}
case kObjectPoolCid: {
const ObjectPoolPtr raw_object_pool =
static_cast<const ObjectPoolPtr>(this);
intptr_t len = raw_object_pool->untag()->length_;
instance_size = ObjectPool::InstanceSize(len);
break;
}
case kRecordCid: {
const RecordPtr raw_record = static_cast<const RecordPtr>(this);
intptr_t num_fields =
RecordShape(raw_record->untag()->shape()).num_fields();
instance_size = Record::InstanceSize(num_fields);
break;
}
#define SIZE_FROM_CLASS(clazz) case kTypedData##clazz##Cid:
CLASS_LIST_TYPED_DATA(SIZE_FROM_CLASS) {
const TypedDataPtr raw_obj = static_cast<const TypedDataPtr>(this);
intptr_t array_len = Smi::Value(raw_obj->untag()->length());
intptr_t lengthInBytes =
array_len * TypedData::ElementSizeInBytes(class_id);
instance_size = TypedData::InstanceSize(lengthInBytes);
break;
}
#undef SIZE_FROM_CLASS
case kPointerCid:
instance_size = Pointer::InstanceSize();
break;
case kSuspendStateCid: {
const SuspendStatePtr raw_suspend_state =
static_cast<const SuspendStatePtr>(this);
intptr_t frame_capacity = raw_suspend_state->untag()->frame_capacity();
instance_size = SuspendState::InstanceSize(frame_capacity);
break;
}
case kTypeArgumentsCid: {
const TypeArgumentsPtr raw_array =
static_cast<const TypeArgumentsPtr>(this);
intptr_t array_length = Smi::Value(raw_array->untag()->length());
instance_size = TypeArguments::InstanceSize(array_length);
break;
}
case kPcDescriptorsCid: {
const PcDescriptorsPtr raw_descriptors =
static_cast<const PcDescriptorsPtr>(this);
intptr_t length = raw_descriptors->untag()->length_;
instance_size = PcDescriptors::InstanceSize(length);
break;
}
case kCodeSourceMapCid: {
const CodeSourceMapPtr raw_code_source_map =
static_cast<const CodeSourceMapPtr>(this);
intptr_t length = raw_code_source_map->untag()->length_;
instance_size = CodeSourceMap::InstanceSize(length);
break;
}
case kCompressedStackMapsCid: {
const CompressedStackMapsPtr maps =
static_cast<const CompressedStackMapsPtr>(this);
intptr_t length = CompressedStackMaps::PayloadSizeOf(maps);
instance_size = CompressedStackMaps::InstanceSize(length);
break;
}
case kLocalVarDescriptorsCid: {
const LocalVarDescriptorsPtr raw_descriptors =
static_cast<const LocalVarDescriptorsPtr>(this);
intptr_t num_descriptors = raw_descriptors->untag()->num_entries_;
instance_size = LocalVarDescriptors::InstanceSize(num_descriptors);
break;
}
case kExceptionHandlersCid: {
const ExceptionHandlersPtr raw_handlers =
static_cast<const ExceptionHandlersPtr>(this);
intptr_t num_handlers = raw_handlers->untag()->num_entries();
instance_size = ExceptionHandlers::InstanceSize(num_handlers);
break;
}
case kFreeListElement: {
uword addr = UntaggedObject::ToAddr(this);
FreeListElement* element = reinterpret_cast<FreeListElement*>(addr);
instance_size = element->HeapSize(tags);
break;
}
case kForwardingCorpse: {
uword addr = UntaggedObject::ToAddr(this);
ForwardingCorpse* element = reinterpret_cast<ForwardingCorpse*>(addr);
instance_size = element->HeapSize(tags);
break;
}
case kWeakSerializationReferenceCid: {
instance_size = WeakSerializationReference::InstanceSize();
break;
}
default: {
// Get the (constant) instance size out of the class object.
// TODO(koda): Add Size(ClassTable*) interface to allow caching in loops.
auto isolate_group = IsolateGroup::Current();
#if defined(DEBUG)
auto class_table = isolate_group->heap_walk_class_table();
if (!class_table->IsValidIndex(class_id) ||
!class_table->HasValidClassAt(class_id)) {
FATAL("Invalid cid: %" Pd ", obj: %p, tags: %x. Corrupt heap?",
class_id, this, static_cast<uint32_t>(tags));
}
ASSERT(class_table->SizeAt(class_id) > 0);
#endif // DEBUG
instance_size = isolate_group->heap_walk_class_table()->SizeAt(class_id);
}
}
ASSERT(instance_size != 0);
#if defined(DEBUG)
intptr_t tags_size = SizeTag::decode(tags);
if ((class_id == kArrayCid) && (instance_size > tags_size && tags_size > 0)) {
// TODO(22501): Array::MakeFixedLength could be in the process of shrinking
// the array (see comment therein), having already updated the tags but not
// yet set the new length. Wait a millisecond and try again.
int retries_remaining = 1000; // ... but not forever.
do {
OS::Sleep(1);
const ArrayPtr raw_array = static_cast<const ArrayPtr>(this);
intptr_t array_length = Smi::Value(raw_array->untag()->length());
instance_size = Array::InstanceSize(array_length);
} while ((instance_size > tags_size) && (--retries_remaining > 0));
}
if ((instance_size != tags_size) && (tags_size != 0)) {
FATAL("Size mismatch: %" Pd " from class vs %" Pd " from tags %" Px "\n",
instance_size, tags_size, tags);
}
#endif // DEBUG
return instance_size;
}
intptr_t UntaggedObject::VisitPointersPredefined(ObjectPointerVisitor* visitor,
intptr_t class_id) {
ASSERT(class_id < kNumPredefinedCids);
intptr_t size = 0;
switch (class_id) {
#define RAW_VISITPOINTERS(clazz) \
case k##clazz##Cid: { \
clazz##Ptr raw_obj = static_cast<clazz##Ptr>(this); \
size = Untagged##clazz::Visit##clazz##Pointers(raw_obj, visitor); \
break; \
}
CLASS_LIST_NO_OBJECT(RAW_VISITPOINTERS)
#undef RAW_VISITPOINTERS
#define RAW_VISITPOINTERS(clazz) case kTypedData##clazz##Cid:
CLASS_LIST_TYPED_DATA(RAW_VISITPOINTERS) {
TypedDataPtr raw_obj = static_cast<TypedDataPtr>(this);
size = UntaggedTypedData::VisitTypedDataPointers(raw_obj, visitor);
break;
}
#undef RAW_VISITPOINTERS
#define RAW_VISITPOINTERS(clazz) case kExternalTypedData##clazz##Cid:
CLASS_LIST_TYPED_DATA(RAW_VISITPOINTERS) {
auto raw_obj = static_cast<ExternalTypedDataPtr>(this);
size = UntaggedExternalTypedData::VisitExternalTypedDataPointers(raw_obj,
visitor);
break;
}
#undef RAW_VISITPOINTERS
case kByteDataViewCid:
case kUnmodifiableByteDataViewCid:
#define RAW_VISITPOINTERS(clazz) \
case kTypedData##clazz##ViewCid: \
case kUnmodifiableTypedData##clazz##ViewCid:
CLASS_LIST_TYPED_DATA(RAW_VISITPOINTERS) {
auto raw_obj = static_cast<TypedDataViewPtr>(this);
size =
UntaggedTypedDataView::VisitTypedDataViewPointers(raw_obj, visitor);
break;
}
#undef RAW_VISITPOINTERS
case kByteBufferCid: {
InstancePtr raw_obj = static_cast<InstancePtr>(this);
size = UntaggedInstance::VisitInstancePointers(raw_obj, visitor);
break;
}
#define RAW_VISITPOINTERS(clazz) case kFfi##clazz##Cid:
CLASS_LIST_FFI_TYPE_MARKER(RAW_VISITPOINTERS) {
// NativeType do not have any fields or type arguments.
size = HeapSize();
break;
}
#undef RAW_VISITPOINTERS
case kFreeListElement: {
uword addr = UntaggedObject::ToAddr(this);
FreeListElement* element = reinterpret_cast<FreeListElement*>(addr);
size = element->HeapSize();
break;
}
case kForwardingCorpse: {
uword addr = UntaggedObject::ToAddr(this);
ForwardingCorpse* forwarder = reinterpret_cast<ForwardingCorpse*>(addr);
size = forwarder->HeapSize();
break;
}
case kNullCid:
case kNeverCid:
size = HeapSize();
break;
default:
FATAL("Invalid cid: %" Pd ", obj: %p, tags: %x. Corrupt heap?", class_id,
this, static_cast<uint32_t>(tags_));
break;
}
#if defined(DEBUG)
ASSERT(size != 0);
const intptr_t expected_size = HeapSize();
// In general we expect that visitors return exactly the same size that
// HeapSize would compute. However in case of Arrays we might have a
// discrepancy when concurrently visiting an array that is being shrunk with
// Array::MakeFixedLength: the visitor might have visited the full array while
// here we are observing a smaller HeapSize().
ASSERT(size == expected_size ||
(class_id == kArrayCid && size > expected_size));
return size; // Prefer larger size.
#else
return size;
#endif
}
void UntaggedObject::VisitPointersPrecise(ObjectPointerVisitor* visitor) {
intptr_t class_id = GetClassId();
if ((class_id != kInstanceCid) && (class_id < kNumPredefinedCids)) {
VisitPointersPredefined(visitor, class_id);
return;
}
// N.B.: Not using the heap size!
uword next_field_offset = visitor->class_table()
->At(class_id)
->untag()
->host_next_field_offset_in_words_
<< kCompressedWordSizeLog2;
ASSERT(next_field_offset > 0);
uword obj_addr = UntaggedObject::ToAddr(this);
uword from = obj_addr + sizeof(UntaggedObject);
uword to = obj_addr + next_field_offset - kCompressedWordSize;
const auto first = reinterpret_cast<CompressedObjectPtr*>(from);
const auto last = reinterpret_cast<CompressedObjectPtr*>(to);
const auto unboxed_fields_bitmap =
visitor->class_table()->GetUnboxedFieldsMapAt(class_id);
if (!unboxed_fields_bitmap.IsEmpty()) {
intptr_t bit = sizeof(UntaggedObject) / kCompressedWordSize;
for (CompressedObjectPtr* current = first; current <= last; current++) {
if (!unboxed_fields_bitmap.Get(bit++)) {
visitor->VisitCompressedPointers(heap_base(), current, current);
}
}
} else {
visitor->VisitCompressedPointers(heap_base(), first, last);
}
}
// Most objects are visited with this function. It calls the from() and to()
// methods on the raw object to get the first and last cells that need
// visiting.
#define REGULAR_VISITOR(Type) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
ASSERT_UNCOMPRESSED(Type); \
visitor->VisitPointers(raw_obj->untag()->from(), raw_obj->untag()->to()); \
return Type::InstanceSize(); \
}
#if !defined(DART_COMPRESSED_POINTERS)
#define COMPRESSED_VISITOR(Type) REGULAR_VISITOR(Type)
#else
#define COMPRESSED_VISITOR(Type) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
ASSERT_COMPRESSED(Type); \
visitor->VisitCompressedPointers(raw_obj->heap_base(), \
raw_obj->untag()->from(), \
raw_obj->untag()->to()); \
return Type::InstanceSize(); \
}
#endif
// It calls the from() and to() methods on the raw object to get the first and
// last cells that need visiting.
//
// Though as opposed to Similar to [REGULAR_VISITOR] this visitor will call the
// specialized VisitTypedDataViewPointers
#define TYPED_DATA_VIEW_VISITOR(Type) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
ASSERT_COMPRESSED(Type); \
visitor->VisitTypedDataViewPointers(raw_obj, raw_obj->untag()->from(), \
raw_obj->untag()->to()); \
return Type::InstanceSize(); \
}
// For variable length objects. get_length is a code snippet that gets the
// length of the object, which is passed to InstanceSize and the to() method.
#define VARIABLE_VISITOR(Type, get_length) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
intptr_t length = get_length; \
visitor->VisitPointers(raw_obj->untag()->from(), \
raw_obj->untag()->to(length)); \
return Type::InstanceSize(length); \
}
#if !defined(DART_COMPRESSED_POINTERS)
#define VARIABLE_COMPRESSED_VISITOR(Type, get_length) \
VARIABLE_VISITOR(Type, get_length)
#else
#define VARIABLE_COMPRESSED_VISITOR(Type, get_length) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
intptr_t length = get_length; \
visitor->VisitCompressedPointers(raw_obj->heap_base(), \
raw_obj->untag()->from(), \
raw_obj->untag()->to(length)); \
return Type::InstanceSize(length); \
}
#endif
// For fixed-length objects that don't have any pointers that need visiting.
#define NULL_VISITOR(Type) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
ASSERT_NOTHING_TO_VISIT(Type); \
return Type::InstanceSize(); \
}
// For objects that don't have any pointers that need visiting, but have a
// variable length.
#define VARIABLE_NULL_VISITOR(Type, get_length) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
/* Make sure that we got here with the tagged pointer as this. */ \
ASSERT(raw_obj->IsHeapObject()); \
ASSERT_NOTHING_TO_VISIT(Type); \
intptr_t length = get_length; \
return Type::InstanceSize(length); \
}
// For objects that are never instantiated on the heap.
#define UNREACHABLE_VISITOR(Type) \
intptr_t Untagged##Type::Visit##Type##Pointers( \
Type##Ptr raw_obj, ObjectPointerVisitor* visitor) { \
UNREACHABLE(); \
return 0; \
}
COMPRESSED_VISITOR(Class)
COMPRESSED_VISITOR(PatchClass)
COMPRESSED_VISITOR(ClosureData)
COMPRESSED_VISITOR(FfiTrampolineData)
COMPRESSED_VISITOR(Script)
COMPRESSED_VISITOR(Library)
COMPRESSED_VISITOR(Namespace)
COMPRESSED_VISITOR(KernelProgramInfo)
COMPRESSED_VISITOR(WeakSerializationReference)
VARIABLE_COMPRESSED_VISITOR(WeakArray, Smi::Value(raw_obj->untag()->length()))
COMPRESSED_VISITOR(Type)
COMPRESSED_VISITOR(FunctionType)
COMPRESSED_VISITOR(RecordType)
COMPRESSED_VISITOR(TypeParameter)
COMPRESSED_VISITOR(Function)
COMPRESSED_VISITOR(Closure)
COMPRESSED_VISITOR(LibraryPrefix)
COMPRESSED_VISITOR(Bytecode)
REGULAR_VISITOR(SingleTargetCache)
REGULAR_VISITOR(UnlinkedCall)
NULL_VISITOR(MonomorphicSmiableCall)
REGULAR_VISITOR(ICData)
REGULAR_VISITOR(MegamorphicCache)
COMPRESSED_VISITOR(ApiError)
COMPRESSED_VISITOR(LanguageError)
COMPRESSED_VISITOR(UnhandledException)
COMPRESSED_VISITOR(UnwindError)
COMPRESSED_VISITOR(GrowableObjectArray)
COMPRESSED_VISITOR(Map)
COMPRESSED_VISITOR(Set)
COMPRESSED_VISITOR(ExternalTypedData)
TYPED_DATA_VIEW_VISITOR(TypedDataView)
COMPRESSED_VISITOR(ReceivePort)
COMPRESSED_VISITOR(StackTrace)
COMPRESSED_VISITOR(RegExp)
COMPRESSED_VISITOR(WeakProperty)
COMPRESSED_VISITOR(WeakReference)
COMPRESSED_VISITOR(Finalizer)
COMPRESSED_VISITOR(FinalizerEntry)
COMPRESSED_VISITOR(NativeFinalizer)
COMPRESSED_VISITOR(MirrorReference)
COMPRESSED_VISITOR(UserTag)
REGULAR_VISITOR(SubtypeTestCache)
COMPRESSED_VISITOR(LoadingUnit)
COMPRESSED_VISITOR(TypeParameters)
VARIABLE_COMPRESSED_VISITOR(TypeArguments,
Smi::Value(raw_obj->untag()->length()))
VARIABLE_COMPRESSED_VISITOR(LocalVarDescriptors, raw_obj->untag()->num_entries_)
VARIABLE_COMPRESSED_VISITOR(ExceptionHandlers, raw_obj->untag()->num_entries())
VARIABLE_COMPRESSED_VISITOR(Context, raw_obj->untag()->num_variables_)
VARIABLE_COMPRESSED_VISITOR(Array, Smi::Value(raw_obj->untag()->length()))
VARIABLE_COMPRESSED_VISITOR(
TypedData,
TypedData::ElementSizeInBytes(raw_obj->GetClassIdOfHeapObject()) *
Smi::Value(raw_obj->untag()->length()))
VARIABLE_COMPRESSED_VISITOR(ContextScope, raw_obj->untag()->num_variables_)
VARIABLE_COMPRESSED_VISITOR(Record,
RecordShape(raw_obj->untag()->shape()).num_fields())
NULL_VISITOR(Sentinel)
REGULAR_VISITOR(InstructionsTable)
NULL_VISITOR(Mint)
NULL_VISITOR(Double)
NULL_VISITOR(Float32x4)
NULL_VISITOR(Int32x4)
NULL_VISITOR(Float64x2)
NULL_VISITOR(Bool)
NULL_VISITOR(Capability)
NULL_VISITOR(SendPort)
NULL_VISITOR(TransferableTypedData)
COMPRESSED_VISITOR(Pointer)
NULL_VISITOR(DynamicLibrary)
VARIABLE_NULL_VISITOR(Instructions, Instructions::Size(raw_obj))
VARIABLE_NULL_VISITOR(InstructionsSection, InstructionsSection::Size(raw_obj))
VARIABLE_NULL_VISITOR(PcDescriptors, raw_obj->untag()->length_)
VARIABLE_NULL_VISITOR(CodeSourceMap, raw_obj->untag()->length_)
VARIABLE_NULL_VISITOR(CompressedStackMaps,
CompressedStackMaps::PayloadSizeOf(raw_obj))
VARIABLE_NULL_VISITOR(OneByteString, Smi::Value(raw_obj->untag()->length()))
VARIABLE_NULL_VISITOR(TwoByteString, Smi::Value(raw_obj->untag()->length()))
// Abstract types don't have their visitor called.
UNREACHABLE_VISITOR(AbstractType)
UNREACHABLE_VISITOR(CallSiteData)
UNREACHABLE_VISITOR(TypedDataBase)
UNREACHABLE_VISITOR(Error)
UNREACHABLE_VISITOR(FinalizerBase)
UNREACHABLE_VISITOR(Number)
UNREACHABLE_VISITOR(Integer)
UNREACHABLE_VISITOR(String)
UNREACHABLE_VISITOR(FutureOr)
// Smi has no heap representation.
UNREACHABLE_VISITOR(Smi)
intptr_t UntaggedField::VisitFieldPointers(FieldPtr raw_obj,
ObjectPointerVisitor* visitor) {
ASSERT(raw_obj->IsHeapObject());
ASSERT_COMPRESSED(Field);
visitor->VisitCompressedPointers(
raw_obj->heap_base(), raw_obj->untag()->from(), raw_obj->untag()->to());
if (visitor->trace_values_through_fields()) {
if (Field::StaticBit::decode(raw_obj->untag()->kind_bits_)) {
visitor->isolate_group()->ForEachIsolate(
[&](Isolate* isolate) {
intptr_t index =
Smi::Value(raw_obj->untag()->host_offset_or_field_id());
visitor->VisitPointer(&isolate->field_table()->table()[index]);
},
/*at_safepoint=*/true);
}
}
return Field::InstanceSize();
}
intptr_t UntaggedSuspendState::VisitSuspendStatePointers(
SuspendStatePtr raw_obj,
ObjectPointerVisitor* visitor) {
ASSERT(raw_obj->IsHeapObject());
ASSERT_COMPRESSED(SuspendState);
if (visitor->CanVisitSuspendStatePointers(raw_obj)) {
visitor->VisitCompressedPointers(
raw_obj->heap_base(), raw_obj->untag()->from(), raw_obj->untag()->to());
const uword pc = raw_obj->untag()->pc_;
if (pc != 0) {
Thread* thread = Thread::Current();
ASSERT(thread != nullptr);
ASSERT(thread->isolate_group() == visitor->isolate_group());
const uword sp = reinterpret_cast<uword>(raw_obj->untag()->payload());
StackFrame frame(thread);
frame.pc_ = pc;
frame.sp_ = sp;
frame.fp_ = sp + raw_obj->untag()->frame_size_;
frame.VisitObjectPointers(visitor);
}
}
return SuspendState::InstanceSize(raw_obj->untag()->frame_capacity());
}
bool UntaggedCode::ContainsPC(const ObjectPtr raw_obj, uword pc) {
if (!raw_obj->IsCode()) return false;
auto const raw_code = static_cast<const CodePtr>(raw_obj);
const uword start = Code::PayloadStartOf(raw_code);
const uword size = Code::PayloadSizeOf(raw_code);
return (pc - start) <= size; // pc may point just past last instruction.
}
intptr_t UntaggedCode::VisitCodePointers(CodePtr raw_obj,
ObjectPointerVisitor* visitor) {
visitor->VisitPointers(raw_obj->untag()->from(), raw_obj->untag()->to());
UntaggedCode* obj = raw_obj->untag();
intptr_t length = Code::PtrOffBits::decode(obj->state_bits_);
#if defined(TARGET_ARCH_IA32)
// On IA32 only we embed pointers to objects directly in the generated
// instructions. The variable portion of a Code object describes where to
// find those pointers for tracing.
if (Code::AliveBit::decode(obj->state_bits_)) {
uword entry_point = Code::PayloadStartOf(raw_obj);
for (intptr_t i = 0; i < length; i++) {
int32_t offset = obj->data()[i];
visitor->VisitPointer(reinterpret_cast<ObjectPtr*>(entry_point + offset));
}
}
return Code::InstanceSize(length);
#else
// On all other architectures, objects are referenced indirectly through
// either an ObjectPool or Thread.
ASSERT(length == 0);
return Code::InstanceSize(0);
#endif
}
bool UntaggedBytecode::ContainsPC(ObjectPtr raw_obj, uword pc) {
if (raw_obj->IsBytecode()) {
BytecodePtr raw_bytecode = static_cast<BytecodePtr>(raw_obj);
uword start = raw_bytecode->untag()->instructions_;
uword size = raw_bytecode->untag()->instructions_size_;
return (pc - start) <= size; // pc may point past last instruction.
}
return false;
}
intptr_t UntaggedObjectPool::VisitObjectPoolPointers(
ObjectPoolPtr raw_obj,
ObjectPointerVisitor* visitor) {
const intptr_t length = raw_obj->untag()->length_;
UntaggedObjectPool::Entry* entries = raw_obj->untag()->data();
uint8_t* entry_bits = raw_obj->untag()->entry_bits();
for (intptr_t i = 0; i < length; ++i) {
ObjectPool::EntryType entry_type =
ObjectPool::TypeBits::decode(entry_bits[i]);
if (entry_type == ObjectPool::EntryType::kTaggedObject) {
visitor->VisitPointer(&entries[i].raw_obj_);
}
}
return ObjectPool::InstanceSize(length);
}
bool UntaggedInstructions::ContainsPC(const InstructionsPtr raw_instr,
uword pc) {
const uword start = Instructions::PayloadStart(raw_instr);
const uword size = Instructions::Size(raw_instr);
// We use <= instead of < here because the saved-pc can be outside the
// instruction stream if the last instruction is a call we don't expect to
// return (e.g. because it throws an exception).
return (pc - start) <= size;
}
intptr_t UntaggedInstance::VisitInstancePointers(
InstancePtr raw_obj,
ObjectPointerVisitor* visitor) {
// Make sure that we got here with the tagged pointer as this.
ASSERT(raw_obj->IsHeapObject());
uword tags = raw_obj->untag()->tags_;
intptr_t instance_size = SizeTag::decode(tags);
if (instance_size == 0) {
instance_size =
visitor->class_table()->SizeAt(raw_obj->GetClassIdOfHeapObject());
}
// Calculate the first and last raw object pointer fields.
uword obj_addr = UntaggedObject::ToAddr(raw_obj);
uword from = obj_addr + sizeof(UntaggedObject);
uword to = obj_addr + instance_size - kCompressedWordSize;
visitor->VisitCompressedPointers(raw_obj->heap_base(),
reinterpret_cast<CompressedObjectPtr*>(from),
reinterpret_cast<CompressedObjectPtr*>(to));
return instance_size;
}
intptr_t UntaggedImmutableArray::VisitImmutableArrayPointers(
ImmutableArrayPtr raw_obj,
ObjectPointerVisitor* visitor) {
return UntaggedArray::VisitArrayPointers(raw_obj, visitor);
}
intptr_t UntaggedConstMap::VisitConstMapPointers(
ConstMapPtr raw_obj,
ObjectPointerVisitor* visitor) {
return UntaggedMap::VisitMapPointers(raw_obj, visitor);
}
intptr_t UntaggedConstSet::VisitConstSetPointers(
ConstSetPtr raw_obj,
ObjectPointerVisitor* visitor) {
return UntaggedSet::VisitSetPointers(raw_obj, visitor);
}
void UntaggedObject::RememberCard(ObjectPtr const* slot) {
Page::Of(static_cast<ObjectPtr>(this))->RememberCard(slot);
}
#if defined(DART_COMPRESSED_POINTERS)
void UntaggedObject::RememberCard(CompressedObjectPtr const* slot) {
Page::Of(static_cast<ObjectPtr>(this))->RememberCard(slot);
}
#endif
const char* UntaggedPcDescriptors::KindToCString(Kind k) {
switch (k) {
#define ENUM_CASE(name, init) \
case Kind::k##name: \
return #name;
FOR_EACH_RAW_PC_DESCRIPTOR(ENUM_CASE)
#undef ENUM_CASE
default:
return nullptr;
}
}
bool UntaggedPcDescriptors::ParseKind(const char* cstr, Kind* out) {
ASSERT(cstr != nullptr && out != nullptr);
#define ENUM_CASE(name, init) \
if (strcmp(#name, cstr) == 0) { \
*out = Kind::k##name; \
return true; \
}
FOR_EACH_RAW_PC_DESCRIPTOR(ENUM_CASE)
#undef ENUM_CASE
return false;
}
#undef PREFIXED_NAME
} // namespace dart