dart::Become Class Reference

#include <become.h>

Public Member Functions
	Become ()
	~Become ()
void	Add (const Object &before, const Object &after)
void	Forward ()
void	Exchange ()
void	VisitObjectPointers (ObjectPointerVisitor *visitor)

Static Public Member Functions
static void	MakeDummyObject (const Instance &instance)
static void	FollowForwardingPointers (Thread *thread)

Detailed Description

Definition at line 96 of file become.h.

Constructor & Destructor Documentation

Become()

dart::Become::Become

(

)

Definition at line 221 of file become.cc.

               {
  IsolateGroup* group = Thread::Current()->isolate_group();
  ASSERT(group->become() == nullptr);  // Only one outstanding become at a time.
  group->set_become(this);
}

~Become()

dart::Become::~Become

(

)

Definition at line 227 of file become.cc.

                {
  Thread::Current()->isolate_group()->set_become(nullptr);
}

Member Function Documentation

Add()

void dart::Become::Add	(	const Object &	before,
		const Object &	after
	)

Definition at line 231 of file become.cc.

                                                          {
  pointers_.Add(before.ptr());
  pointers_.Add(after.ptr());
}

Exchange()

void dart::Become::Exchange ( )

inline

Definition at line 103 of file become.h.

{ UNIMPLEMENTED(); }

FollowForwardingPointers()

void dart::Become::FollowForwardingPointers ( Thread *  thread )

static

Definition at line 330 of file become.cc.

                                                    {
  // N.B.: We forward the heap before forwarding the stack. This limits the
  // amount of following of forwarding pointers needed to get at stack maps.
  auto isolate_group = thread->isolate_group();
  Heap* heap = isolate_group->heap();
 
  // Clear the store buffer; will be rebuilt as we forward the heap.
  isolate_group->ReleaseStoreBuffers();
  isolate_group->store_buffer()->Reset();
 
  ForwardPointersVisitor pointer_visitor(thread);
 
  {
    // Heap pointers.
    WritableCodeLiteralsScope writable_code(heap);
    ForwardHeapPointersVisitor object_visitor(&pointer_visitor);
    heap->VisitObjects(&object_visitor);
    pointer_visitor.VisitingObject(nullptr);
  }
 
  // C++ pointers.
  isolate_group->VisitObjectPointers(&pointer_visitor,
                                     ValidationPolicy::kValidateFrames);
#ifndef PRODUCT
  isolate_group->ForEachIsolate(
      [&](Isolate* isolate) {
        ObjectIdRing* ring = isolate->object_id_ring();
        if (ring != nullptr) {
          ring->VisitPointers(&pointer_visitor);
        }
      },
      /*at_safepoint=*/true);
#endif  // !PRODUCT
 
  // Weak persistent handles.
  ForwardHeapPointersHandleVisitor handle_visitor(thread);
  isolate_group->VisitWeakPersistentHandles(&handle_visitor);
}

Forward()

void dart::Become::Forward

(

)

Definition at line 275 of file become.cc.

                     {
  if (pointers_.length() == 0) {
    return;
  }
 
  Thread* thread = Thread::Current();
  auto heap = thread->isolate_group()->heap();
 
  TIMELINE_FUNCTION_GC_DURATION(thread, "Become::ElementsForwardIdentity");
  HeapIterationScope his(thread);
 
  // Setup forwarding pointers.
  for (intptr_t i = 0; i < pointers_.length(); i += 2) {
    ObjectPtr before = pointers_[i];
    ObjectPtr after = pointers_[i + 1];
 
    if (before == after) {
      InvalidForwarding(before, after, "Cannot self-forward");
    }
    if (before->IsImmediateObject()) {
      InvalidForwarding(before, after, "Cannot forward immediates");
    }
    if (after->IsImmediateObject()) {
      InvalidForwarding(before, after, "Cannot target immediates");
    }
    if (before->untag()->InVMIsolateHeap()) {
      InvalidForwarding(before, after, "Cannot forward VM heap objects");
    }
    if (before->IsForwardingCorpse() && !IsDummyObject(before)) {
      InvalidForwarding(before, after, "Cannot forward to multiple targets");
    }
    if (after->IsForwardingCorpse()) {
      // The Smalltalk become does allow this, and for very special cases
      // it is important (shape changes to Class or Mixin), but as these
      // cases do not arise in Dart, better to prohibit it.
      InvalidForwarding(before, after, "No indirect chains of forwarding");
    }
 
    ForwardObjectTo(before, after);
    heap->ForwardWeakEntries(before, after);
#if defined(HASH_IN_OBJECT_HEADER)
    Object::SetCachedHashIfNotSet(after, Object::GetCachedHash(before));
#endif
  }
 
  FollowForwardingPointers(thread);
 
#if defined(DEBUG)
  for (intptr_t i = 0; i < pointers_.length(); i += 2) {
    ASSERT(pointers_[i] == pointers_[i + 1]);
  }
#endif
  pointers_.Clear();
}

MakeDummyObject()

void dart::Become::MakeDummyObject ( const Instance &  instance )

static

Definition at line 242 of file become.cc.

                                                     {
  // Make the forward pointer point to itself.
  // This is needed to distinguish it from a real forward object.
  ForwardObjectTo(instance.ptr(), instance.ptr());
}

VisitObjectPointers()

void dart::Become::VisitObjectPointers

(

ObjectPointerVisitor *

visitor

)

Definition at line 236 of file become.cc.

                                                              {
  if (pointers_.length() != 0) {
    visitor->VisitPointers(&pointers_[0], pointers_.length());
  }
}

---

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

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