Don't overload FreeListElement for become.

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"
-#include "vm/freelist.h"
 #include "vm/isolate_reload.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/safepoint.h"
 #include "vm/timeline.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_reload);
 
+
+ForwardingCorpse* ForwardingCorpse::AsForwarder(uword addr, intptr_t size) {
+  ASSERT(size >= kObjectAlignment);
+  ASSERT(Utils::IsAligned(size, kObjectAlignment));
+
+  ForwardingCorpse* result = reinterpret_cast<ForwardingCorpse*>(addr);
+
+  uword tags = 0;
+  tags = RawObject::SizeTag::update(size, tags);
+  tags = RawObject::ClassIdTag::update(kForwardingCorpse, tags);
+
+  result->tags_ = tags;
+  if (size > RawObject::SizeTag::kMaxSizeTag) {
+    *result->SizeAddress() = size;
+  }
+  result->set_target(Object::null());
+  return result;
+}
+
+
+void ForwardingCorpse::InitOnce() {
+  ASSERT(sizeof(ForwardingCorpse) == kObjectAlignment);
+  ASSERT(OFFSET_OF(ForwardingCorpse, tags_) == Object::tags_offset());
+}
+
+
 // Free list elements are used as a marker for forwarding objects. This is
 // safe because we cannot reach free list elements from live objects. Ideally
 // forwarding objects would have their own class id. See TODO below.
 static bool IsForwardingObject(RawObject* object) {
-  return object->IsHeapObject() && object->IsFreeListElement();
+  return object->IsHeapObject() && object->IsForwardingCorpse();
 }
 
 
 static RawObject* GetForwardedObject(RawObject* object) {
   ASSERT(IsForwardingObject(object));
   uword addr = reinterpret_cast<uword>(object) - kHeapObjectTag;
-  FreeListElement* forwarder = reinterpret_cast<FreeListElement*>(addr);
-  RawObject* new_target = reinterpret_cast<RawObject*>(forwarder->next());
-  return new_target;
+  ForwardingCorpse* forwarder = reinterpret_cast<ForwardingCorpse*>(addr);
+  return forwarder->target();
 }
 
 
 static void ForwardObjectTo(RawObject* before_obj, RawObject* after_obj) {
   const intptr_t size_before = before_obj->Size();
 
-  // TODO(rmacnak): We should use different cids for forwarding corpses and
-  // free list elements.
   uword corpse_addr = reinterpret_cast<uword>(before_obj) - kHeapObjectTag;
-  FreeListElement* forwarder = FreeListElement::AsElement(corpse_addr,
-                                                          size_before);
-  forwarder->set_next(reinterpret_cast<FreeListElement*>(after_obj));
+  ForwardingCorpse* forwarder = ForwardingCorpse::AsForwarder(corpse_addr,
+                                                              size_before);
+  forwarder->set_target(after_obj);
   if (!IsForwardingObject(before_obj)) {
     FATAL("become: ForwardObjectTo failure.");
   }
   // Still need to be able to iterate over the forwarding corpse.
   const intptr_t size_after = before_obj->Size();
   if (size_before != size_after) {
     FATAL("become: Before and after sizes do not match.");
   }
 }
 
@@ skipping 64 matching lines @@
   intptr_t count() const { return count_; }
 
  private:
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardHeapPointersHandleVisitor);
 };
 
 
 #if defined(DEBUG)
-class NoFreeListTargetsVisitor : public ObjectPointerVisitor {
+class NoForwardingCorpseTargetsVisitor : public ObjectPointerVisitor {
  public:
-  explicit NoFreeListTargetsVisitor(Isolate* isolate)
+  explicit NoForwardingCorpseTargetsVisitor(Isolate* isolate)
       : ObjectPointerVisitor(isolate) { }
 
   virtual void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** p = first; p <= last; p++) {
       RawObject* target = *p;
       if (target->IsHeapObject()) {
-        ASSERT(!target->IsFreeListElement());
+        ASSERT(!target->IsForwardingCorpse());
       }
     }
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(NoFreeListTargetsVisitor);
+  DISALLOW_COPY_AND_ASSIGN(NoForwardingCorpseTargetsVisitor);
 };
 #endif
 
 
 void Become::ElementsForwardIdentity(const Array& before, const Array& after) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   Heap* heap = isolate->heap();
 
   {
     // TODO(rmacnak): Investigate why this is necessary.
     heap->CollectGarbage(Heap::kNew);
   }
 
   TIMELINE_FUNCTION_GC_DURATION(thread, "Become::ElementsForwardIdentity");
   HeapIterationScope his;
 
 #if defined(DEBUG)
   {
     // There should be no pointers to free list elements / forwarding corpses.
-    NoFreeListTargetsVisitor visitor(isolate);
+    NoForwardingCorpseTargetsVisitor visitor(isolate);
     isolate->VisitObjectPointers(&visitor, true);
     heap->VisitObjectPointers(&visitor);
   }
 #endif
 
   // 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 (after_obj->IsFreeListElement()) {
+    if (before_obj->IsForwardingCorpse()) {
+      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 17 matching lines @@
               handle_visitor.count());
   }
 
 #if defined(DEBUG)
   for (intptr_t i = 0; i < before.Length(); i++) {
     ASSERT(before.At(i) == after.At(i));
   }
 
   {
     // There should be no pointers to forwarding corpses.
-    NoFreeListTargetsVisitor visitor(isolate);
+    NoForwardingCorpseTargetsVisitor visitor(isolate);
     isolate->VisitObjectPointers(&visitor, true);
     heap->VisitObjectPointers(&visitor);
   }
 #endif
 }
 
 }  // namespace dart