Don't overload FreeListElement for become.

runtime/vm/become.h

Index: runtime/vm/become.h
diff --git a/runtime/vm/become.h b/runtime/vm/become.h
index 977355364628c4bea80a24bbcbd8883a8af5ea7f..109e5880cae021c37811caec4b5ab220e317a294 100644
--- a/runtime/vm/become.h
+++ b/runtime/vm/become.h
@@ -6,11 +6,66 @@
 #define VM_BECOME_H_
 
 #include "vm/allocation.h"
+#include "vm/raw_object.h"
 
 namespace dart {
 
 class Array;
 
+// Objects on the left-hand side of a become are tranformed into forwarding
+// corpses pointing to the right-hand side. Compare the representation of a

[Cutch, 2016/06/02 14:09:53]

you talk about "right-hand" side in the comment then use "target" in the API.
Maybe consistently use "source" and "target"?

[rmacnak, 2016/06/02 17:57:06]

Changed to 

Objects that are a source in a become are tranformed into forwarding            
                                                                                
                 
corpses pointing to the corresponding target. Forwarding corpses have the       
                                                                                
                 
same heap sizes as the source object to ensure the heap remains walkable.       
                                                                                
                 
If the heap sizes is small enough to be encoded in the size field of the        
                                                                                
                 
header, a forwarding corpse consists only of a header and the target pointer.   
                                                                                
                 
If the heap size is too big to be encoded in the header's size field, the       
                                                                                
                 
word after the target pointer contains the size.  This is the same              
                                                                                
                 
representation as a FreeListElement. 

+// FreeListElement.

[Cutch, 2016/06/02 14:09:53]

I don't understand the last sentence.

+class ForwardingCorpse {
+ public:
+  RawObject* target() const {
+    return target_;
+  }
+  void set_target(RawObject* target) {
+    target_ = target;
+  }
+
+  intptr_t Size() {
+    intptr_t size = RawObject::SizeTag::decode(tags_);
+    if (size != 0) return size;
+    return *SizeAddress();
+  }
+
+  static ForwardingCorpse* AsForwarder(uword addr, intptr_t size);
+
+  static void InitOnce();
+
+  // Used to allocate class for free list elements in Object::InitOnce.

[siva, 2016/06/02 00:23:36]

"free list elements" => "forwarding corpse elements"

[rmacnak, 2016/06/02 17:57:06]

Done.

+  class FakeInstance {
+   public:
+    FakeInstance() { }
+    static cpp_vtable vtable() { return 0; }
+    static intptr_t InstanceSize() { return 0; }
+    static intptr_t NextFieldOffset() { return -kWordSize; }
+    static const ClassId kClassId = kForwardingCorpse;
+    static bool IsInstance() { return true; }
+
+   private:
+    DISALLOW_ALLOCATION();
+    DISALLOW_COPY_AND_ASSIGN(FakeInstance);
+  };
+
+ private:
+  // This layout mirrors the layout of RawObject.
+  uword tags_;
+  RawObject* target_;

[siva, 2016/06/02 00:23:36]

Why did you do it this way instead of adding a RawForwardingCorpse class that
subclasses RawObject ?

[rmacnak, 2016/06/02 17:57:06]

As discussed offline, this follows the precedent of FreeListElement, the other
heap object that should never be reachable from a live object.

+
+  // Returns the address of the embedded size.
+  intptr_t* SizeAddress() const {
+    uword addr = reinterpret_cast<uword>(&target_) + kWordSize;
+    return reinterpret_cast<intptr_t*>(addr);
+  }
+
+  // ForwardingCorpses cannot be allocated. Instead references to them are
+  // created using the AsForwarder factory method.
+  DISALLOW_ALLOCATION();
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ForwardingCorpse);
+};
+
 // TODO(johnmccutchan): Refactor this class so that it is not all static and
 // provides utility methods for building the mapping of before and after.
 class Become : public AllStatic {