Don't overload FreeListElement for become.

runtime/vm/become.h

 // 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.
 
 #ifndef VM_BECOME_H_
 #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 {
  public:
   // Smalltalk's one-way bulk become (Array>>#elementsForwardIdentityTo:).
   // Redirects all pointers to elements of 'before' to the corresponding element
   // in 'after'. Every element in 'before' is guaranteed to be not reachable.
   // Useful for atomically applying behavior and schema changes.
   static void ElementsForwardIdentity(const Array& before, const Array& after);
 };
 
 }  // namespace dart
 
 #endif  // VM_BECOME_H_