[Compiler] Add compile to CompilerDispatcherJob.

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 <memory>
 
 #include "src/allocation.h"
@@ skipping 36 matching lines @@
   // whereas successful compilation ensures the {is_compiled} predicate on the
   // given function holds (except for live-edit, which compiles the world).
 
   static bool Compile(Handle<JSFunction> function, ClearExceptionFlag flag);
   static bool CompileBaseline(Handle<JSFunction> function);
   static bool CompileOptimized(Handle<JSFunction> function, ConcurrencyMode);
   static bool CompileDebugCode(Handle<JSFunction> function);
   static bool CompileDebugCode(Handle<SharedFunctionInfo> shared);
   static MaybeHandle<JSArray> CompileForLiveEdit(Handle<Script> script);
 
+  // Prepare a compilation job for unoptimized code. Requires ParseAndAnalyse.
+  static CompilationJob* PrepareUnoptimizedCompilationJob(

[Michael Starzinger, 2016/08/19 10:54:14]

This API method doesn't seem to be used nor implemented. Can we drop it?

[Michael Starzinger, 2016/08/19 10:57:10]

Ooops, overlooked the obvious. Please disregard this comment.

+      CompilationInfo* info);
+
   // Generate and install code from previously queued compilation job.
-  static void FinalizeCompilationJob(CompilationJob* job);
+  static bool FinalizeCompilationJob(CompilationJob* job);
 
   // Give the compiler a chance to perform low-latency initialization tasks of
   // the given {function} on its instantiation. Note that only the runtime will
   // offer this chance, optimized closure instantiation will not call this.
   static void PostInstantiation(Handle<JSFunction> function, PretenureFlag);
 
   // Parser::Parse, then Compiler::Analyze.
   static bool ParseAndAnalyze(ParseInfo* info);
   // Rewrite, analyze scopes, and renumber.
   static bool Analyze(ParseInfo* info);
@@ skipping 513 matching lines @@
 
   // Report a persistent failure, disable future optimization on the function.
   // Should only be called on optimization compilation jobs.
   Status AbortOptimization(BailoutReason reason) {
     DCHECK(info_->IsOptimizing());
     info_->AbortOptimization(reason);
     state_ = State::kFailed;
     return FAILED;
   }
 
-  void RecordOptimizationStats();
-
   State state() const { return state_; }
   CompilationInfo* info() const { return info_; }
   Isolate* isolate() const { return info()->isolate(); }
 
  protected:
   // Overridden by the actual implementation.
   virtual Status PrepareJobImpl() = 0;
   virtual Status ExecuteJobImpl() = 0;
   virtual Status FinalizeJobImpl() = 0;
 
  private:
+  void RecordOptimizedCompilationStats() const;
+  void RecordUnoptimizedCompilationStats() const;
+
+  void RecordCompilationStats() const {

[Michael Starzinger, 2016/08/19 10:54:14]

nit: I'm not sure the job itself should record stats in the finalization phase.
I think it should be the caller who decides whether and how to record stats. Can
we remove this helper, make the two rcoed function public and call them directly
from within Compiler::FinalizeCompilationJob instead?

[rmcilroy, 2016/08/22 13:27:08]

Done.

+    if (info_->IsOptimizing()) {
+      RecordOptimizedCompilationStats();
+    } else {
+      RecordUnoptimizedCompilationStats();
+    }
+  }
+
   CompilationInfo* info_;
   base::TimeDelta time_taken_to_prepare_;
   base::TimeDelta time_taken_to_execute_;
   base::TimeDelta time_taken_to_finalize_;
   const char* compiler_name_;
   State state_;
 
   MUST_USE_RESULT Status UpdateState(Status status, State next_state) {
     if (status == SUCCEEDED)
       state_ = next_state;
     else
       state_ = State::kFailed;
     return status;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_H_