Implemented schema change for the isolate reload operation.

runtime/vm/become.cc

 // Copyright (c) 2016, 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/become.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 
 #include "vm/dart_api_state.h"
@@ skipping 130 matching lines @@
 
   intptr_t count() const { return count_; }
 
  private:
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardHeapPointersHandleVisitor);
 };
 
 
+void Become::MakeDummyObject(const Instance& instance) {
+  // Make the forward pointer point to itself.
+  // This is needed to distinguish it from a real forward object.
+  ForwardObjectTo(instance.raw(), instance.raw());
+}
+
+static bool IsDummyObject(RawObject* object) {
+  if (!object->IsForwardingCorpse()) return false;
+  return GetForwardedObject(object) == object;
+}
+
 void Become::ElementsForwardIdentity(const Array& before, const Array& after) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Heap* heap = isolate->heap();
 
   TIMELINE_FUNCTION_GC_DURATION(thread, "Become::ElementsForwardIdentity");
   HeapIterationScope his;
 
   // Setup forwarding pointers.
   ASSERT(before.Length() == after.Length());
   for (intptr_t i = 0; i < before.Length(); i++) {
     RawObject* before_obj = before.At(i);
     RawObject* after_obj = after.At(i);
 
     if (before_obj == after_obj) {
       FATAL("become: Cannot self-forward");
     }
     if (!before_obj->IsHeapObject()) {
       FATAL("become: Cannot forward immediates");
     }
     if (!after_obj->IsHeapObject()) {
       FATAL("become: Cannot become an immediates");
     }
     if (before_obj->IsVMHeapObject()) {
       FATAL("become: Cannot forward VM heap objects");
     }
-    if (before_obj->IsForwardingCorpse()) {
+    if (before_obj->IsForwardingCorpse() && !IsDummyObject(before_obj)) {
       FATAL("become: Cannot forward to multiple targets");
     }
     if (after_obj->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.
       FATAL("become: No indirect chains of forwarding");
     }
 
     ForwardObjectTo(before_obj, after_obj);
@@ skipping 24 matching lines @@
   }
 
 #if defined(DEBUG)
   for (intptr_t i = 0; i < before.Length(); i++) {
     ASSERT(before.At(i) == after.At(i));
   }
 #endif
 }
 
 }  // namespace dart