VM: [Kernel] Clone Field objects if building IL during background compilation.

runtime/vm/kernel_to_il.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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 2342 matching lines @@
 }
 
 
 Fragment FlowGraphBuilder::LoadClassId() {
   LoadClassIdInstr* load = new (Z) LoadClassIdInstr(Pop());
   Push(load);
   return Fragment(load);
 }
 
 
+const dart::Field& MayCloneField(Zone* zone, const dart::Field& field) {
+  if ((Compiler::IsBackgroundCompilation() ||
+       FLAG_force_clone_compiler_objects) &&
+      field.IsOriginal()) {
+    return dart::Field::ZoneHandle(zone, field.CloneFromOriginal());
+  } else {
+    ASSERT(field.IsZoneHandle());
+    return field;
+  }
+}
+
+
 Fragment FlowGraphBuilder::LoadField(const dart::Field& field) {
-  LoadFieldInstr* load = new (Z)
-      LoadFieldInstr(Pop(), &field, AbstractType::ZoneHandle(Z, field.type()),
-                     TokenPosition::kNoSource);
+  LoadFieldInstr* load = new (Z) LoadFieldInstr(
+      Pop(), &MayCloneField(Z, field),
+      AbstractType::ZoneHandle(Z, field.type()), TokenPosition::kNoSource);
   Push(load);
   return Fragment(load);
 }
 
 
 Fragment FlowGraphBuilder::LoadField(intptr_t offset, intptr_t class_id) {
   LoadFieldInstr* load = new (Z) LoadFieldInstr(
       Pop(), offset, AbstractType::ZoneHandle(Z), TokenPosition::kNoSource);
   load->set_result_cid(class_id);
   Push(load);
@@ skipping 25 matching lines @@
     LoadLocalInstr* load =
         new (Z) LoadLocalInstr(*variable, TokenPosition::kNoSource);
     instructions <<= load;
     Push(load);
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::InitStaticField(const dart::Field& field) {
-  InitStaticFieldInstr* init = new (Z) InitStaticFieldInstr(Pop(), field);
+  InitStaticFieldInstr* init =
+      new (Z) InitStaticFieldInstr(Pop(), MayCloneField(Z, field));
   return Fragment(init);
 }
 
 
 Fragment FlowGraphBuilder::LoadStaticField() {
   LoadStaticFieldInstr* load =
       new (Z) LoadStaticFieldInstr(Pop(), TokenPosition::kNoSource);
   Push(load);
   return Fragment(load);
 }
@@ skipping 97 matching lines @@
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
     const dart::Field& field,
     StoreBarrierType emit_store_barrier) {
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
   }
-  StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
-      field, Pop(), value, emit_store_barrier, TokenPosition::kNoSource);
+  StoreInstanceFieldInstr* store = new (Z)
+      StoreInstanceFieldInstr(MayCloneField(Z, field), Pop(), value,
+                              emit_store_barrier, TokenPosition::kNoSource);
   return Fragment(store);
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(const dart::Field& field) {
   Fragment instructions;
+  const dart::Field& field_clone = MayCloneField(Z, field);
   if (FLAG_use_field_guards) {
     LocalVariable* store_expression = MakeTemporary();
     instructions += LoadLocal(store_expression);
-    instructions += GuardFieldClass(field, Thread::Current()->GetNextDeoptId());
+    instructions +=
+        GuardFieldClass(field_clone, Thread::Current()->GetNextDeoptId());
     instructions += LoadLocal(store_expression);
     instructions +=
-        GuardFieldLength(field, Thread::Current()->GetNextDeoptId());
+        GuardFieldLength(field_clone, Thread::Current()->GetNextDeoptId());
   }
-  instructions += StoreInstanceField(field);
+  instructions += StoreInstanceField(field_clone);
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
     intptr_t offset,
     StoreBarrierType emit_store_barrier) {
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
@@ skipping 16 matching lines @@
     StoreLocalInstr* store =
         new (Z) StoreLocalInstr(*variable, Pop(), TokenPosition::kNoSource);
     instructions <<= store;
     Push(store);
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreStaticField(const dart::Field& field) {
-  return Fragment(
-      new (Z) StoreStaticFieldInstr(field, Pop(), TokenPosition::kNoSource));
+  return Fragment(new (Z) StoreStaticFieldInstr(MayCloneField(Z, field), Pop(),
+                                                TokenPosition::kNoSource));
 }
 
 
 Fragment FlowGraphBuilder::StringInterpolate() {
   Value* array = Pop();
   StringInterpolateInstr* interpolate =
       new (Z) StringInterpolateInstr(array, TokenPosition::kNoSource);
   Push(interpolate);
   return Fragment(interpolate);
 }
@@ skipping 3167 matching lines @@
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)