In background compilation make a copy of Field in order to freeze its state

runtime/vm/redundancy_elimination.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/redundancy_elimination.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
@@ skipping 463 matching lines @@
 
  private:
   Place(uword flags, Definition* instance, intptr_t selector)
       : flags_(flags),
         instance_(instance),
         raw_selector_(selector),
         id_(0) {
   }
 
   bool SameField(const Place* other) const {
-    return (kind() == kField) ? (field().raw() == other->field().raw())
-                              : (offset_in_bytes_ == other->offset_in_bytes_);
+    return (kind() == kField) ?
+        (field().Original() == other->field().Original()) :
+        (offset_in_bytes_ == other->offset_in_bytes_);
   }
 
   intptr_t FieldHashcode() const {
-    return (kind() == kField) ? reinterpret_cast<intptr_t>(field().raw())
+    return (kind() == kField) ? reinterpret_cast<intptr_t>(field().Original())
                               : offset_in_bytes_;
   }
 
   void set_representation(Representation rep) {
     flags_ = RepresentationBits::update(rep, flags_);
   }
 
   void set_kind(Kind kind) {
     flags_ = KindBits::update(kind, flags_);
   }
@@ skipping 2578 matching lines @@
 void AllocationSinking::DetachMaterializations() {
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     materializations_[i]->previous()->LinkTo(materializations_[i]->next());
   }
 }
 
 
 // Add a field/offset to the list of fields if it is not yet present there.
 static bool AddSlot(ZoneGrowableArray<const Object*>* slots,
                     const Object& slot) {
+  ASSERT(slot.IsSmi() || slot.IsField());
+  ASSERT(!slot.IsField() || Field::Cast(slot).IsOriginal());
   for (intptr_t i = 0; i < slots->length(); i++) {
     if ((*slots)[i]->raw() == slot.raw()) {
       return false;
     }
   }
   slots->Add(&slot);
   return true;
 }
 
 
@@ skipping 176 matching lines @@
   // Collect all fields that are written for this instance.
   ZoneGrowableArray<const Object*>* slots =
       new(Z) ZoneGrowableArray<const Object*>(5);
 
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = use->next_use()) {
     StoreInstanceFieldInstr* store = use->instruction()->AsStoreInstanceField();
     if ((store != NULL) && (store->instance()->definition() == alloc)) {
       if (!store->field().IsNull()) {
-        AddSlot(slots, store->field());
+        AddSlot(slots, *store->field().OriginalAsHandle(Z));
       } else {
         AddSlot(slots, Smi::ZoneHandle(Z, Smi::New(store->offset_in_bytes())));
       }
     }
   }
 
   if (alloc->ArgumentCount() > 0) {
     AllocateObjectInstr* alloc_object = alloc->AsAllocateObject();
     ASSERT(alloc_object->ArgumentCount() == 1);
     intptr_t type_args_offset =
@@ skipping 163 matching lines @@
         join->phis_ = NULL;
       } else {
         join->phis_->TruncateTo(to_index);
       }
     }
   }
 }
 
 
 }  // namespace dart