Fix data race when concurrent compilation is aborted due to dependency change.

src/compiler.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
@@ skipping 67 matching lines @@
     kMustNotHaveEagerFrame = 1 << 10,
     kDeoptimizationSupport = 1 << 11,
     kDebug = 1 << 12,
     kCompilingForDebugging = 1 << 13,
     kParseRestriction = 1 << 14,
     kSerializing = 1 << 15,
     kContextSpecializing = 1 << 16,
     kInliningEnabled = 1 << 17,
     kTypingEnabled = 1 << 18,
     kDisableFutureOptimization = 1 << 19,
-    kAbortedDueToDependency = 1 << 20,
-    kToplevel = 1 << 21
+    kToplevel = 1 << 20
   };
 
   CompilationInfo(Handle<JSFunction> closure, Zone* zone);
   CompilationInfo(Isolate* isolate, Zone* zone);
   virtual ~CompilationInfo();
 
   Isolate* isolate() const {
     return isolate_;
   }
   Zone* zone() { return zone_; }
@@ skipping 264 matching lines @@
   Handle<Foreign> object_wrapper() {
     if (object_wrapper_.is_null()) {
       object_wrapper_ =
           isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
     }
     return object_wrapper_;
   }
 
   void AbortDueToDependencyChange() {
     DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
-    SetFlag(kAbortedDueToDependency);
+    aborted_due_to_dependency_change_ = true;
   }
 
   bool HasAbortedDueToDependencyChange() const {
     DCHECK(!OptimizingCompilerThread::IsOptimizerThread(isolate()));
-    return GetFlag(kAbortedDueToDependency);
+    return aborted_due_to_dependency_change_;
   }
 
   bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) {
     return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure_);
   }
 
   int optimization_id() const { return optimization_id_; }
 
   AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
   void SetAstValueFactory(AstValueFactory* ast_value_factory,
@@ skipping 118 matching lines @@
   int parameter_count_;
 
   Handle<Foreign> object_wrapper_;
 
   int optimization_id_;
 
   AstValueFactory* ast_value_factory_;
   bool ast_value_factory_owned_;
   AstNode::IdGen ast_node_id_gen_;
 
+  // This flag is used by the main thread to track whether this compilation
+  // should be abandoned due to dependency change.
+  bool aborted_due_to_dependency_change_;
+
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 
 // Exactly like a CompilationInfo, except also creates and enters a
 // Zone on construction and deallocates it on exit.
 class CompilationInfoWithZone: public CompilationInfo {
  public:
   explicit CompilationInfoWithZone(Handle<Script> script)
       : CompilationInfo(script, &zone_),
@@ skipping 217 matching lines @@
   Zone zone_;
   unsigned info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_