VM: Fix race between background compiler and guarded cid update.

runtime/vm/compiler.cc

 // Copyright (c) 2012, 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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 430 matching lines @@
 
 class CompileParsedFunctionHelper : public ValueObject {
  public:
   CompileParsedFunctionHelper(ParsedFunction* parsed_function,
                               bool optimized,
                               intptr_t osr_id)
       : parsed_function_(parsed_function),
         optimized_(optimized),
         osr_id_(osr_id),
         thread_(Thread::Current()),
-        field_invalidation_gen_at_start_(isolate()->field_invalidation_gen()),
         loading_invalidation_gen_at_start_(
             isolate()->loading_invalidation_gen()) {
-    if (Compiler::IsBackgroundCompilation()) {
-      isolate()->ClearDisablingFieldList();
-    }
   }
 
   bool Compile(CompilationPipeline* pipeline);
 
  private:
   ParsedFunction* parsed_function() const { return parsed_function_; }
   bool optimized() const { return optimized_; }
   intptr_t osr_id() const { return osr_id_; }
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
-  intptr_t field_invalidation_gen_at_start() const {
-    return field_invalidation_gen_at_start_;
-  }
   intptr_t loading_invalidation_gen_at_start() const {
     return loading_invalidation_gen_at_start_;
   }
   void FinalizeCompilation(Assembler* assembler,
                            FlowGraphCompiler* graph_compiler,
                            FlowGraph* flow_graph);
   void CheckIfBackgroundCompilerIsBeingStopped();
 
   ParsedFunction* parsed_function_;
   const bool optimized_;
   const intptr_t osr_id_;
   Thread* const thread_;
-  const intptr_t field_invalidation_gen_at_start_;
   const intptr_t loading_invalidation_gen_at_start_;
 
   DISALLOW_COPY_AND_ASSIGN(CompileParsedFunctionHelper);
 };
 
 
-// Returns true if any of disabling fields is inside the guarded_fields.
-// The number of guarded_fields and disabling-fields is expected to be small
-// (less than 5).
-static bool CheckDisablingFields(
-    Thread* thread,
-    const ZoneGrowableArray<const Field*>& guarded_fields) {
-  Isolate* isolate = thread->isolate();
-  Zone* zone = thread->zone();
-  Field& field = Field::Handle(zone, isolate->GetDisablingField());
-  while (!field.IsNull()) {
-    for (intptr_t i = 0; i < guarded_fields.length(); i++) {
-      if (guarded_fields.At(i)->raw() == field.raw()) {
-        return true;
-      }
-    }
-    // Get next field.
-    field = isolate->GetDisablingField();
-  }
-  return false;
-}
-
-
 void CompileParsedFunctionHelper::FinalizeCompilation(
     Assembler* assembler,
     FlowGraphCompiler* graph_compiler,
     FlowGraph* flow_graph) {
   ASSERT(!FLAG_precompiled_mode);
   const Function& function = parsed_function()->function();
   Zone* const zone = thread()->zone();
 
   CSTAT_TIMER_SCOPE(thread(), codefinalizer_timer);
   // CreateDeoptInfo uses the object pool and needs to be done before
@@ skipping 65 matching lines @@
       function.InstallOptimizedCode(code, is_osr);
       code_was_installed = true;
     } else {
       // Background compilation.
       // Before installing code check generation counts if the code may
       // have become invalid.
       const bool trace_compiler =
           FLAG_trace_compiler || FLAG_trace_optimizing_compiler;
       bool code_is_valid = true;
       if (!flow_graph->parsed_function().guarded_fields()->is_empty()) {
-        if (field_invalidation_gen_at_start() !=
-            isolate()->field_invalidation_gen()) {
-          const ZoneGrowableArray<const Field*>& guarded_fields =
-              *flow_graph->parsed_function().guarded_fields();
-          bool field_conflict = CheckDisablingFields(thread(), guarded_fields);
-          if (field_conflict) {
+        const ZoneGrowableArray<const Field*>& guarded_fields =
+            *flow_graph->parsed_function().guarded_fields();
+        Field& original = Field::Handle();
+        for (intptr_t i = 0; i < guarded_fields.length(); i++) {
+          const Field& field = *guarded_fields[i];
+          ASSERT(!field.IsOriginal());
+          original = field.Original();
+          if (!field.IsConsistentWith(original)) {
             code_is_valid = false;
             if (trace_compiler) {
-              THR_Print("--> FAIL: Field invalidation.");
+              THR_Print("--> FAIL: Field %s guarded state changed.",
+                        field.ToCString());
             }
-         }
+            break;
+          }
         }
       }
       if (loading_invalidation_gen_at_start() !=
           isolate()->loading_invalidation_gen()) {
         code_is_valid = false;
         if (trace_compiler) {
           THR_Print("--> FAIL: Loading invalidation.");
         }
       }
       if (!thread()->cha()->IsConsistentWithCurrentHierarchy()) {
@@ skipping 22 matching lines @@
     }
 
     if (code_was_installed) {
       // The generated code was compiled under certain assumptions about
       // class hierarchy and field types. Register these dependencies
       // to ensure that the code will be deoptimized if they are violated.
       thread()->cha()->RegisterDependencies(code);
 
       const ZoneGrowableArray<const Field*>& guarded_fields =
           *flow_graph->parsed_function().guarded_fields();
+      Field& field = Field::Handle();
       for (intptr_t i = 0; i < guarded_fields.length(); i++) {
-        const Field* field = guarded_fields[i];
-        field->RegisterDependentCode(code);
+        field = guarded_fields[i]->Original();
+        field.RegisterDependentCode(code);
       }
     }
   } else {  // not optimized.
     if (function.ic_data_array() == Array::null()) {
       function.SaveICDataMap(
           graph_compiler->deopt_id_to_ic_data(),
           Array::Handle(zone, graph_compiler->edge_counters_array()));
     }
     function.set_unoptimized_code(code);
     function.AttachCode(code);
@@ skipping 1523 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart