[turbofan] Enable concurrent (re)compilation.

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"
 #include "src/compilation-dependencies.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
+// Forward declarations.
 class AstValueFactory;
 class HydrogenCodeStub;
 class ParseInfo;
 class ScriptData;
 
+namespace compiler {
+
+// Forward declarations.
+class Pipeline;
+
+}  // namespace compiler
+
+
 struct OffsetRange {
   OffsetRange(int from, int to) : from(from), to(to) {}
   int from;
   int to;
 };
 
 
 // This class encapsulates encoding and decoding of sources positions from
 // which hydrogen values originated.
 // When FLAG_track_hydrogen_positions is set this object encodes the
@@ skipping 475 matching lines @@
 // A helper class that calls the three compilation phases in
 // Crankshaft and keeps track of its state.  The three phases
 // CreateGraph, OptimizeGraph and GenerateAndInstallCode can either
 // fail, bail-out to the full code generator or succeed.  Apart from
 // their return value, the status of the phase last run can be checked
 // using last_status().
 class OptimizedCompileJob: public ZoneObject {
  public:
   explicit OptimizedCompileJob(CompilationInfo* info)
       : info_(info),
+        pipeline_(nullptr),
         graph_builder_(NULL),
         graph_(NULL),
         chunk_(NULL),
         last_status_(FAILED),
-        awaiting_install_(false) { }
+        awaiting_install_(false) {}
+  ~OptimizedCompileJob();
 
   enum Status {
     FAILED, BAILED_OUT, SUCCEEDED
   };
 
   MUST_USE_RESULT Status CreateGraph();
   MUST_USE_RESULT Status OptimizeGraph();
   MUST_USE_RESULT Status GenerateCode();
 
   Status last_status() const { return last_status_; }
   CompilationInfo* info() const { return info_; }
+  compiler::Pipeline* pipeline() const { return pipeline_; }
   Isolate* isolate() const { return info()->isolate(); }
 
   Status RetryOptimization(BailoutReason reason) {
     info_->RetryOptimization(reason);
     return SetLastStatus(BAILED_OUT);
   }
 
   Status AbortOptimization(BailoutReason reason) {
     info_->AbortOptimization(reason);
     return SetLastStatus(BAILED_OUT);
   }
 
   void WaitForInstall() {
     DCHECK(info_->is_osr());
     awaiting_install_ = true;
   }
 
   bool IsWaitingForInstall() { return awaiting_install_; }
 
  private:
-  CompilationInfo* info_;
+  CompilationInfo* const info_;
+  compiler::Pipeline* pipeline_;
   HOptimizedGraphBuilder* graph_builder_;
   HGraph* graph_;
   LChunk* chunk_;
   base::TimeDelta time_taken_to_create_graph_;
   base::TimeDelta time_taken_to_optimize_;
   base::TimeDelta time_taken_to_codegen_;
   Status last_status_;
   bool awaiting_install_;
 
   MUST_USE_RESULT Status SetLastStatus(Status status) {
@@ skipping 118 matching lines @@
   Zone zone_;
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_