[compiler-dispatcher] Make compiler jobs abstract (reland)

Reland of https://chromium-review.googlesource.com/c/558290/

Makes compiler dispatcher jobs an abstract interface, with unoptimized
compile jobs as an implementation of this interface.

Bug: v8:6537
Change-Id: Ia85781f72c7aaca497896ca4efa91ada97e43b1c
Reviewed-on: https://chromium-review.googlesource.com/589154
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#46940}

BUILD.gn

@@ -1246,6 +1246,8 @@ v8_source_set("v8_base") {
     "src/compiler-dispatcher/compiler-dispatcher.h",
     "src/compiler-dispatcher/optimizing-compile-dispatcher.cc",
     "src/compiler-dispatcher/optimizing-compile-dispatcher.h",
+    "src/compiler-dispatcher/unoptimized-compile-job.cc",
+    "src/compiler-dispatcher/unoptimized-compile-job.h",
     "src/compiler.cc",
     "src/compiler.h",
     "src/compiler/access-builder.cc",

src/compiler-dispatcher/compiler-dispatcher-job.h

@@ -5,168 +5,54 @@
 #ifndef V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_
 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_JOB_H_
 
-#include <memory>
-
-#include "include/v8.h"
-#include "src/base/macros.h"
-#include "src/globals.h"
+#include "src/contexts.h"
 #include "src/handles.h"
-#include "testing/gtest/include/gtest/gtest_prod.h"  // nogncheck
 
 namespace v8 {
 namespace internal {
 
-class AstValueFactory;
-class AstStringConstants;
-class CompilerDispatcherTracer;
-class CompilationInfo;
-class CompilationJob;
-class DeferredHandles;
-class FunctionLiteral;
-class Isolate;
-class ParseInfo;
-class Parser;
 class SharedFunctionInfo;
-class String;
-class UnicodeCache;
-class Utf16CharacterStream;
-
-enum class CompileJobStatus {
-  kInitial,
-  kReadyToParse,
-  kParsed,
-  kReadyToAnalyze,
-  kAnalyzed,
-  kReadyToCompile,
-  kCompiled,
-  kFailed,
-  kDone,
-};
 
-class V8_EXPORT_PRIVATE CompileJobFinishCallback {
- public:
-  virtual ~CompileJobFinishCallback() {}
-  virtual void ParseFinished(std::unique_ptr<ParseInfo> parse_info) = 0;
-};
+class UnoptimizedCompileJob;
 
 class V8_EXPORT_PRIVATE CompilerDispatcherJob {
  public:
-  // Creates a CompilerDispatcherJob in the initial state.
-  CompilerDispatcherJob(Isolate* isolate, CompilerDispatcherTracer* tracer,
-                        Handle<SharedFunctionInfo> shared,
-                        size_t max_stack_size);
-  // TODO(wiktorg) document it better once I know how it relates to whole stuff
-  // Creates a CompilerDispatcherJob in ready to parse top-level function state.
-  CompilerDispatcherJob(CompilerDispatcherTracer* tracer, size_t max_stack_size,
-                        Handle<String> source, int start_position,
-                        int end_position, LanguageMode language_mode,
-                        int function_literal_id, bool native, bool module,
-                        bool is_named_expression, uint32_t hash_seed,
-                        AccountingAllocator* zone_allocator, int compiler_hints,
-                        const AstStringConstants* ast_string_constants,
-                        CompileJobFinishCallback* finish_callback);
-  // Creates a CompilerDispatcherJob in the analyzed state.
-  CompilerDispatcherJob(Isolate* isolate, CompilerDispatcherTracer* tracer,
-                        Handle<Script> script,
-                        Handle<SharedFunctionInfo> shared,
-                        FunctionLiteral* literal, ParseInfo* outer_parse_info,
-                        std::shared_ptr<DeferredHandles> compile_handles,
-                        size_t max_stack_size);
-  ~CompilerDispatcherJob();
-
-  bool has_context() const { return !context_.is_null(); }
-  Context* context() { return *context_; }
-
-  Handle<SharedFunctionInfo> shared() const { return shared_; }
-
-  // Returns true if this CompilerDispatcherJob was created for the given
-  // function.
-  bool IsAssociatedWith(Handle<SharedFunctionInfo> shared) const;
-
-  bool IsFinished() {
-    return status() == CompileJobStatus::kDone ||
-           status() == CompileJobStatus::kFailed;
-  }
-
-  bool IsFailed() { return status() == CompileJobStatus::kFailed; }
+  enum Type { kUnoptimizedCompile };
+
+  virtual ~CompilerDispatcherJob() {}
+
+  virtual Type type() const = 0;
+
+  // Returns true if this CompilerDispatcherJob has finished (either with a
+  // success or a failure).
+  virtual bool IsFinished() = 0;
+
+  // Returns true if this CompilerDispatcherJob has failed.
+  virtual bool IsFailed() = 0;
 
   // Return true if the next step can be run on any thread, that is when both
   // StepNextOnMainThread and StepNextOnBackgroundThread could be used for the
   // next step.
-  bool CanStepNextOnAnyThread() {
-    return status() == CompileJobStatus::kReadyToParse ||
-           status() == CompileJobStatus::kReadyToCompile;
-  }
+  virtual bool CanStepNextOnAnyThread() = 0;
 
   // Step the job forward by one state on the main thread.
-  void StepNextOnMainThread();
+  virtual void StepNextOnMainThread() = 0;
 
   // Step the job forward by one state on a background thread.
-  void StepNextOnBackgroundThread();
+  virtual void StepNextOnBackgroundThread() = 0;
 
   // Transition from any state to kInitial and free all resources.
-  void ResetOnMainThread();
+  virtual void ResetOnMainThread() = 0;
 
   // Estimate how long the next step will take using the tracer.
-  double EstimateRuntimeOfNextStepInMs() const;
+  virtual double EstimateRuntimeOfNextStepInMs() const = 0;
 
   // Even though the name does not imply this, ShortPrint() must only be invoked
   // on the main thread.
-  void ShortPrint();
-
- private:
-  friend class CompilerDispatcherTest;
-  friend class CompilerDispatcherJobTest;
-
-  CompileJobStatus status() const { return status_; }
-
-  CompileJobStatus status_;
-  Isolate* isolate_;
-  CompilerDispatcherTracer* tracer_;
-  Handle<Context> context_;            // Global handle.
-  Handle<SharedFunctionInfo> shared_;  // Global handle.
-  Handle<String> source_;        // Global handle.
-  Handle<String> wrapper_;       // Global handle.
-  std::unique_ptr<v8::String::ExternalStringResourceBase> source_wrapper_;
-  size_t max_stack_size_;
-  CompileJobFinishCallback* finish_callback_ = nullptr;
-
-  // Members required for parsing.
-  std::unique_ptr<UnicodeCache> unicode_cache_;
-  std::unique_ptr<Utf16CharacterStream> character_stream_;
-  std::unique_ptr<ParseInfo> parse_info_;
-  std::unique_ptr<Parser> parser_;
-
-  // Members required for compiling.
-  std::unique_ptr<Zone> compile_zone_;
-  std::unique_ptr<CompilationInfo> compile_info_;
-  std::unique_ptr<CompilationJob> compile_job_;
-
-  bool trace_compiler_dispatcher_jobs_;
-
-  // Transition from kInitial to kReadyToParse.
-  void PrepareToParseOnMainThread();
-
-  // Transition from kReadyToParse to kParsed (or kDone if there is
-  // finish_callback).
-  void Parse();
-
-  // Transition from kParsed to kReadyToAnalyze (or kFailed).
-  void FinalizeParsingOnMainThread();
-
-  // Transition from kReadyToAnalyze to kAnalyzed (or kFailed).
-  void AnalyzeOnMainThread();
-
-  // Transition from kAnalyzed to kReadyToCompile (or kFailed).
-  void PrepareToCompileOnMainThread();
-
-  // Transition from kReadyToCompile to kCompiled.
-  void Compile();
-
-  // Transition from kCompiled to kDone (or kFailed).
-  void FinalizeCompilingOnMainThread();
+  virtual void ShortPrint() = 0;
 
-  DISALLOW_COPY_AND_ASSIGN(CompilerDispatcherJob);
+  // Casts to implementations.
+  const UnoptimizedCompileJob* AsUnoptimizedCompileJob() const;
 };
 
 }  // namespace internal

src/compiler-dispatcher/compiler-dispatcher.cc

@@ -11,6 +11,7 @@
 #include "src/compilation-info.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-job.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
+#include "src/compiler-dispatcher/unoptimized-compile-job.h"
 #include "src/flags.h"
 #include "src/objects-inl.h"
 
@@ -26,15 +27,6 @@ bool DoNextStepOnMainThread(Isolate* isolate, CompilerDispatcherJob* job,
   DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
                "V8.CompilerDispatcherForgroundStep");
-
-  // Ensure we are in the correct context for the job.
-  SaveContext save(isolate);
-  if (job->has_context()) {
-    isolate->set_context(job->context());
-  } else {
-    DCHECK(job->CanStepNextOnAnyThread());
-  }
-
   job->StepNextOnMainThread();
 
   DCHECK_EQ(job->IsFailed(), isolate->has_pending_exception());
@@ -170,7 +162,7 @@ CompilerDispatcher::CompilerDispatcher(Isolate* isolate, Platform* platform,
       tracer_(new CompilerDispatcherTracer(isolate_)),
       task_manager_(new CancelableTaskManager()),
       next_job_id_(0),
-      shared_to_job_id_(isolate->heap()),
+      shared_to_unoptimized_job_id_(isolate->heap()),
       memory_pressure_level_(MemoryPressureLevel::kNone),
       abort_(false),
       idle_task_scheduled_(false),
@@ -222,14 +214,7 @@ bool CompilerDispatcher::CanEnqueue(Handle<SharedFunctionInfo> function) {
 CompilerDispatcher::JobId CompilerDispatcher::Enqueue(
     std::unique_ptr<CompilerDispatcherJob> job) {
   DCHECK(!job->IsFinished());
-  bool added;
-  JobMap::const_iterator it;
-  std::tie(it, added) =
-      jobs_.insert(std::make_pair(next_job_id_++, std::move(job)));
-  DCHECK(added);
-  if (!it->second->shared().is_null()) {
-    shared_to_job_id_.Set(it->second->shared(), it->first);
-  }
+  JobMap::const_iterator it = InsertJob(std::move(job));
   ConsiderJobForBackgroundProcessing(it->second.get());
   ScheduleIdleTaskIfNeeded();
   return it->first;
@@ -238,15 +223,7 @@ CompilerDispatcher::JobId CompilerDispatcher::Enqueue(
 CompilerDispatcher::JobId CompilerDispatcher::EnqueueAndStep(
     std::unique_ptr<CompilerDispatcherJob> job) {
   DCHECK(!job->IsFinished());
-  bool added;
-  JobMap::const_iterator it;
-  std::tie(it, added) =
-      jobs_.insert(std::make_pair(next_job_id_++, std::move(job)));
-  DCHECK(added);
-  if (!it->second->shared().is_null()) {
-    shared_to_job_id_.Set(it->second->shared(), it->first);
-  }
-  JobId id = it->first;
+  JobMap::const_iterator it = InsertJob(std::move(job));
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: stepping ");
     it->second->ShortPrint();
@@ -257,7 +234,7 @@ CompilerDispatcher::JobId CompilerDispatcher::EnqueueAndStep(
   ConsiderJobForBackgroundProcessing(it->second.get());
   RemoveIfFinished(it);
   ScheduleIdleTaskIfNeeded();
-  return id;
+  return it->first;
 }
 
 bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
@@ -272,19 +249,17 @@ bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
     PrintF(" for parse and compile\n");
   }
 
-  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
+  std::unique_ptr<CompilerDispatcherJob> job(new UnoptimizedCompileJob(
       isolate_, tracer_.get(), function, max_stack_size_));
   Enqueue(std::move(job));
   return true;
 }
 
-bool CompilerDispatcher::Enqueue(Handle<String> source, int start_position,
-                                 int end_position, LanguageMode language_mode,
-                                 int function_literal_id, bool native,
-                                 bool module, bool is_named_expression,
-                                 int compiler_hints,
-                                 CompileJobFinishCallback* finish_callback,
-                                 JobId* job_id) {
+bool CompilerDispatcher::Enqueue(
+    Handle<String> source, int start_position, int end_position,
+    LanguageMode language_mode, int function_literal_id, bool native,
+    bool module, bool is_named_expression, int compiler_hints,
+    UnoptimizedCompileJobFinishCallback* finish_callback, JobId* job_id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
                "V8.CompilerDispatcherEnqueue");
   if (!CanEnqueue()) return false;
@@ -294,7 +269,7 @@ bool CompilerDispatcher::Enqueue(Handle<String> source, int start_position,
            start_position);
   }
 
-  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
+  std::unique_ptr<CompilerDispatcherJob> job(new UnoptimizedCompileJob(
       tracer_.get(), max_stack_size_, source, start_position, end_position,
       language_mode, function_literal_id, native, module, is_named_expression,
       isolate_->heap()->HashSeed(), isolate_->allocator(), compiler_hints,
@@ -318,7 +293,7 @@ bool CompilerDispatcher::EnqueueAndStep(Handle<SharedFunctionInfo> function) {
     PrintF(" for parse and compile\n");
   }
 
-  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
+  std::unique_ptr<CompilerDispatcherJob> job(new UnoptimizedCompileJob(
       isolate_, tracer_.get(), function, max_stack_size_));
   EnqueueAndStep(std::move(job));
   return true;
@@ -339,7 +314,7 @@ bool CompilerDispatcher::Enqueue(
     PrintF(" for compile\n");
   }
 
-  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
+  std::unique_ptr<CompilerDispatcherJob> job(new UnoptimizedCompileJob(
       isolate_, tracer_.get(), script, function, literal, outer_parse_info,
       compile_handles, max_stack_size_));
   Enqueue(std::move(job));
@@ -361,7 +336,7 @@ bool CompilerDispatcher::EnqueueAndStep(
     PrintF(" for compile\n");
   }
 
-  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
+  std::unique_ptr<CompilerDispatcherJob> job(new UnoptimizedCompileJob(
       isolate_, tracer_.get(), script, function, literal, outer_parse_info,
       compile_handles, max_stack_size_));
   EnqueueAndStep(std::move(job));
@@ -460,7 +435,7 @@ void CompilerDispatcher::AbortAll(BlockingBehavior blocking) {
       it.second->ResetOnMainThread();
     }
     jobs_.clear();
-    shared_to_job_id_.Clear();
+    shared_to_unoptimized_job_id_.Clear();
     {
       base::LockGuard<base::Mutex> lock(&mutex_);
       DCHECK(pending_background_jobs_.empty());
@@ -546,11 +521,12 @@ void CompilerDispatcher::MemoryPressureNotification(
 
 CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::GetJobFor(
     Handle<SharedFunctionInfo> shared) const {
-  JobId* job_id_ptr = shared_to_job_id_.Find(shared);
+  JobId* job_id_ptr = shared_to_unoptimized_job_id_.Find(shared);
   JobMap::const_iterator job = jobs_.end();
   if (job_id_ptr) {
     job = jobs_.find(*job_id_ptr);
-    DCHECK(job == jobs_.end() || job->second->IsAssociatedWith(shared));
+    DCHECK(job == jobs_.end() ||
+           job->second->AsUnoptimizedCompileJob()->IsAssociatedWith(shared));
   }
   return job;
 }
@@ -751,18 +727,51 @@ CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::RemoveIfFinished(
   return RemoveJob(job);
 }
 
+CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::InsertJob(
+    std::unique_ptr<CompilerDispatcherJob> job) {
+  bool added;
+  JobMap::const_iterator it;
+  std::tie(it, added) =
+      jobs_.insert(std::make_pair(next_job_id_++, std::move(job)));
+  DCHECK(added);
+
+  JobId id = it->first;
+  CompilerDispatcherJob* inserted_job = it->second.get();
+
+  // Maps unoptimized jobs' SFIs to their job id.
+  if (inserted_job->type() == CompilerDispatcherJob::kUnoptimizedCompile) {
+    Handle<SharedFunctionInfo> shared =
+        inserted_job->AsUnoptimizedCompileJob()->shared();
+    if (!shared.is_null()) {
+      shared_to_unoptimized_job_id_.Set(shared, id);
+    }
+  }
+
+  return it;
+}
+
 CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::RemoveJob(
-    CompilerDispatcher::JobMap::const_iterator job) {
-  job->second->ResetOnMainThread();
-  if (!job->second->shared().is_null()) {
-    shared_to_job_id_.Delete(job->second->shared());
+    CompilerDispatcher::JobMap::const_iterator it) {
+  CompilerDispatcherJob* job = it->second.get();
+  job->ResetOnMainThread();
+
+  // Unmaps unoptimized jobs' SFIs to their job id.
+  if (job->type() == CompilerDispatcherJob::kUnoptimizedCompile) {
+    Handle<SharedFunctionInfo> shared =
+        job->AsUnoptimizedCompileJob()->shared();
+    if (!shared.is_null()) {
+      JobId deleted_id = shared_to_unoptimized_job_id_.Delete(shared);
+      USE(deleted_id);
+      DCHECK_EQ(it->first, deleted_id);
+    }
   }
-  job = jobs_.erase(job);
+
+  it = jobs_.erase(it);
   if (jobs_.empty()) {
     base::LockGuard<base::Mutex> lock(&mutex_);
     if (num_background_tasks_ == 0) abort_ = false;
   }
-  return job;
+  return it;
 }
 
 }  // namespace internal

src/compiler-dispatcher/compiler-dispatcher.h

@@ -29,8 +29,9 @@ namespace internal {
 
 class AstValueFactory;
 class CancelableTaskManager;
-class CompileJobFinishCallback;
 class CompilerDispatcherJob;
+class UnoptimizedCompileJob;
+class UnoptimizedCompileJobFinishCallback;
 class CompilerDispatcherTracer;
 class DeferredHandles;
 class FunctionLiteral;
@@ -88,7 +89,8 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   bool Enqueue(Handle<String> source, int start_pos, int end_position,
                LanguageMode language_mode, int function_literal_id, bool native,
                bool module, bool is_named_expression, int compiler_hints,
-               CompileJobFinishCallback* finish_callback, JobId* job_id);
+               UnoptimizedCompileJobFinishCallback* finish_callback,
+               JobId* job_id);
 
   // Like Enqueue, but also advances the job so that it can potentially
   // continue running on a background thread (if at all possible). Returns
@@ -167,6 +169,8 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   JobId EnqueueAndStep(std::unique_ptr<CompilerDispatcherJob> job);
   // Returns job if not removed otherwise iterator following the removed job.
   JobMap::const_iterator RemoveIfFinished(JobMap::const_iterator job);
+  // Returns iterator to the inserted job.
+  JobMap::const_iterator InsertJob(std::unique_ptr<CompilerDispatcherJob> job);
   // Returns iterator following the removed job.
   JobMap::const_iterator RemoveJob(JobMap::const_iterator job);
   bool FinishNow(CompilerDispatcherJob* job);
@@ -188,8 +192,9 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   // Mapping from job_id to job.
   JobMap jobs_;
 
-  // Mapping from SharedFunctionInfo to corresponding JobId;
-  SharedToJobIdMap shared_to_job_id_;
+  // Mapping from SharedFunctionInfo to the corresponding unoptimized
+  // compilation's JobId;
+  SharedToJobIdMap shared_to_unoptimized_job_id_;
 
   base::AtomicValue<v8::MemoryPressureLevel> memory_pressure_level_;
 

src/compiler-dispatcher/unoptimized-compile-job.h

+// Copyright 2016 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_DISPATCHER_UNOPTIMIZED_COMPILE_JOB_H_
+#define V8_COMPILER_DISPATCHER_UNOPTIMIZED_COMPILE_JOB_H_
+
+#include <memory>
+
+#include "include/v8.h"
+#include "src/base/macros.h"
+#include "src/compiler-dispatcher/compiler-dispatcher-job.h"
+#include "src/globals.h"
+
+namespace v8 {
+namespace internal {
+
+class AstValueFactory;
+class AstStringConstants;
+class CompilerDispatcherTracer;
+class CompilationInfo;
+class CompilationJob;
+class DeferredHandles;
+class FunctionLiteral;
+class Isolate;
+class ParseInfo;
+class Parser;
+class SharedFunctionInfo;
+class String;
+class UnicodeCache;
+class Utf16CharacterStream;
+
+class V8_EXPORT_PRIVATE UnoptimizedCompileJobFinishCallback {
+ public:
+  virtual ~UnoptimizedCompileJobFinishCallback() {}
+  virtual void ParseFinished(std::unique_ptr<ParseInfo> parse_info) = 0;
+};
+
+class V8_EXPORT_PRIVATE UnoptimizedCompileJob : public CompilerDispatcherJob {
+ public:
+  enum class Status {
+    kInitial,
+    kReadyToParse,
+    kParsed,
+    kReadyToAnalyze,
+    kAnalyzed,
+    kReadyToCompile,
+    kCompiled,
+    kDone,
+    kFailed,
+  };
+
+  // Creates a UnoptimizedCompileJob in the initial state.
+  UnoptimizedCompileJob(Isolate* isolate, CompilerDispatcherTracer* tracer,
+                        Handle<SharedFunctionInfo> shared,
+                        size_t max_stack_size);
+  // TODO(wiktorg) document it better once I know how it relates to whole stuff
+  // Creates a UnoptimizedCompileJob in ready to parse top-level function state.
+  UnoptimizedCompileJob(CompilerDispatcherTracer* tracer, size_t max_stack_size,
+                        Handle<String> source, int start_position,
+                        int end_position, LanguageMode language_mode,
+                        int function_literal_id, bool native, bool module,
+                        bool is_named_expression, uint32_t hash_seed,
+                        AccountingAllocator* zone_allocator, int compiler_hints,
+                        const AstStringConstants* ast_string_constants,
+                        UnoptimizedCompileJobFinishCallback* finish_callback);
+  // Creates a UnoptimizedCompileJob in the analyzed state.
+  UnoptimizedCompileJob(Isolate* isolate, CompilerDispatcherTracer* tracer,
+                        Handle<Script> script,
+                        Handle<SharedFunctionInfo> shared,
+                        FunctionLiteral* literal, ParseInfo* outer_parse_info,
+                        std::shared_ptr<DeferredHandles> compile_handles,
+                        size_t max_stack_size);
+
+  ~UnoptimizedCompileJob() override;
+
+  Type type() const override { return kUnoptimizedCompile; }
+
+  Handle<SharedFunctionInfo> shared() const { return shared_; }
+
+  // Returns true if this UnoptimizedCompileJob was created for the given
+  // function.
+  bool IsAssociatedWith(Handle<SharedFunctionInfo> shared) const;
+
+  bool IsFinished() override {
+    return status() == Status::kDone || status() == Status::kFailed;
+  }
+
+  bool IsFailed() override { return status() == Status::kFailed; }
+
+  // Return true if the next step can be run on any thread, that is when both
+  // StepNextOnMainThread and StepNextOnBackgroundThread could be used for the
+  // next step.
+  bool CanStepNextOnAnyThread() override {
+    return status() == Status::kReadyToParse ||
+           status() == Status::kReadyToCompile;
+  }
+
+  // Step the job forward by one state on the main thread.
+  void StepNextOnMainThread() override;
+
+  // Step the job forward by one state on a background thread.
+  void StepNextOnBackgroundThread() override;
+
+  // Transition from any state to kInitial and free all resources.
+  void ResetOnMainThread() override;
+
+  // Estimate how long the next step will take using the tracer.
+  double EstimateRuntimeOfNextStepInMs() const override;
+
+  // Even though the name does not imply this, ShortPrint() must only be invoked
+  // on the main thread.
+  void ShortPrint() override;
+
+ private:
+  friend class CompilerDispatcherTest;
+  friend class UnoptimizedCompileJobTest;
+
+  bool has_context() const { return !context_.is_null(); }
+  Context* context() { return *context_; }
+
+  Status status() const { return status_; }
+
+  Status status_;
+  Isolate* isolate_;
+  CompilerDispatcherTracer* tracer_;
+  Handle<Context> context_;            // Global handle.
+  Handle<SharedFunctionInfo> shared_;  // Global handle.
+  Handle<String> source_;              // Global handle.
+  Handle<String> wrapper_;             // Global handle.
+  std::unique_ptr<v8::String::ExternalStringResourceBase> source_wrapper_;
+  size_t max_stack_size_;
+  UnoptimizedCompileJobFinishCallback* finish_callback_ = nullptr;
+
+  // Members required for parsing.
+  std::unique_ptr<UnicodeCache> unicode_cache_;
+  std::unique_ptr<Utf16CharacterStream> character_stream_;
+  std::unique_ptr<ParseInfo> parse_info_;
+  std::unique_ptr<Parser> parser_;
+
+  // Members required for compiling.
+  std::shared_ptr<Zone> compile_zone_;
+  std::unique_ptr<CompilationInfo> compile_info_;
+  std::unique_ptr<CompilationJob> compile_job_;
+
+  bool trace_compiler_dispatcher_jobs_;
+
+  // Transition from kInitial to kReadyToParse.
+  void PrepareToParseOnMainThread();
+
+  // Transition from kReadyToParse to kParsed (or kDone if there is
+  // finish_callback).
+  void Parse();
+
+  // Transition from kParsed to kReadyToAnalyze (or kFailed).
+  void FinalizeParsingOnMainThread();
+
+  // Transition from kReadyToAnalyze to kAnalyzed (or kFailed).
+  void AnalyzeOnMainThread();
+
+  // Transition from kAnalyzed to kReadyToCompile (or kFailed).
+  void PrepareToCompileOnMainThread();
+
+  // Transition from kReadyToCompile to kCompiled.
+  void Compile();
+
+  // Transition from kCompiled to kDone (or kFailed).
+  void FinalizeCompilingOnMainThread();
+
+  DISALLOW_COPY_AND_ASSIGN(UnoptimizedCompileJob);
+};
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_COMPILER_DISPATCHER_UNOPTIMIZED_COMPILE_JOB_H_

src/parsing/parse-info.h

@@ -10,7 +10,7 @@
 #include <vector>
 
 #include "include/v8.h"
-#include "src/compiler-dispatcher/compiler-dispatcher-job.h"
+#include "src/compiler-dispatcher/unoptimized-compile-job.h"
 #include "src/globals.h"
 #include "src/handles.h"
 #include "src/parsing/preparsed-scope-data.h"
@@ -35,7 +35,7 @@ class Utf16CharacterStream;
 class Zone;
 
 // A container for the inputs, configuration options, and outputs of parsing.
-class V8_EXPORT_PRIVATE ParseInfo : public CompileJobFinishCallback {
+class V8_EXPORT_PRIVATE ParseInfo : public UnoptimizedCompileJobFinishCallback {
  public:
   explicit ParseInfo(AccountingAllocator* zone_allocator);
   ParseInfo(Handle<Script> script);

src/v8.gyp

@@ -894,6 +894,8 @@
         'compiler-dispatcher/compiler-dispatcher-tracer.h',
         'compiler-dispatcher/optimizing-compile-dispatcher.cc',
         'compiler-dispatcher/optimizing-compile-dispatcher.h',
+        'compiler-dispatcher/unoptimized-compile-job.cc',
+        'compiler-dispatcher/unoptimized-compile-job.h',
         'compiler.cc',
         'compiler.h',
         'contexts-inl.h',

test/unittests/BUILD.gn

@@ -40,10 +40,10 @@ v8_executable("unittests") {
     "base/utils/random-number-generator-unittest.cc",
     "cancelable-tasks-unittest.cc",
     "char-predicates-unittest.cc",
-    "compiler-dispatcher/compiler-dispatcher-job-unittest.cc",
     "compiler-dispatcher/compiler-dispatcher-tracer-unittest.cc",
     "compiler-dispatcher/compiler-dispatcher-unittest.cc",
     "compiler-dispatcher/optimizing-compile-dispatcher-unittest.cc",
+    "compiler-dispatcher/unoptimized-compile-job-unittest.cc",
     "compiler/branch-elimination-unittest.cc",
     "compiler/bytecode-analysis-unittest.cc",
     "compiler/checkpoint-elimination-unittest.cc",

test/unittests/test-helpers.h

@@ -40,7 +40,7 @@ class ScriptResource : public v8::String::ExternalOneByteStringResource {
   DISALLOW_COPY_AND_ASSIGN(ScriptResource);
 };
 
-class FinishCallback : public CompileJobFinishCallback {
+class FinishCallback : public UnoptimizedCompileJobFinishCallback {
  public:
   void ParseFinished(std::unique_ptr<ParseInfo> result) override {
     result_ = std::move(result);

test/unittests/unittests.gyp

@@ -91,10 +91,10 @@
       'compiler/typer-unittest.cc',
       'compiler/value-numbering-reducer-unittest.cc',
       'compiler/zone-stats-unittest.cc',
-      'compiler-dispatcher/compiler-dispatcher-job-unittest.cc',
       'compiler-dispatcher/compiler-dispatcher-tracer-unittest.cc',
       'compiler-dispatcher/compiler-dispatcher-unittest.cc',
       'compiler-dispatcher/optimizing-compile-dispatcher-unittest.cc',
+      'compiler-dispatcher/unoptimized-compile-job-unittest.cc',
       'counters-unittest.cc',
       'eh-frame-iterator-unittest.cc',
       'eh-frame-writer-unittest.cc',