Create multiple compilation jobs for ignition if compiling multiple literals

src/compiler-dispatcher/compiler-dispatcher-job.cc

 // 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.
 
 #include "src/compiler-dispatcher/compiler-dispatcher-job.h"
 
 #include "src/assert-scope.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/global-handles.h"
@@ skipping 158 matching lines @@
 
 bool CompilerDispatcherJob::PrepareToCompileOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kReadyToAnalyse);
 
   compile_info_.reset(
       new CompilationInfo(parse_info_.get(), Handle<JSFunction>::null()));
 
   DeferredHandleScope scope(isolate_);
   if (Compiler::Analyze(parse_info_.get())) {
-    compile_job_.reset(
-        Compiler::PrepareUnoptimizedCompilationJob(compile_info_.get()));
+    compile_jobs_ =
+        Compiler::PrepareUnoptimizedCompilationJobs(compile_info_.get());
   }
   compile_info_->set_deferred_handles(scope.Detach());
 
-  if (!compile_job_.get()) {
+  if (compile_jobs_.empty()) {
     if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
     status_ = CompileJobStatus::kFailed;
     return false;
   }
 
   can_compile_on_background_thread_ =
-      compile_job_->can_execute_on_background_thread();
+      compile_jobs_.at(0)->can_execute_on_background_thread();
   status_ = CompileJobStatus::kReadyToCompile;
   return true;
 }
 
 void CompilerDispatcherJob::Compile() {
   DCHECK(status() == CompileJobStatus::kReadyToCompile);
   DCHECK(can_compile_on_background_thread_ ||
          ThreadId::Current().Equals(isolate_->thread_id()));
 
   // Disallowing of handle dereference and heap access dealt with in
   // CompilationJob::ExecuteJob.
 
   uintptr_t stack_limit = GetCurrentStackPosition() - max_stack_size_ * KB;
-  compile_job_->set_stack_limit(stack_limit);
 
-  CompilationJob::Status status = compile_job_->ExecuteJob();
-  USE(status);
+  for (auto& job : compile_jobs_) {
+    job->set_stack_limit(stack_limit);
+    if (job->ExecuteJob() == CompilationJob::FAILED) break;
+  }
 
   // Always transition to kCompiled - errors will be reported by
   // FinalizeCompilingOnMainThread.
   status_ = CompileJobStatus::kCompiled;
 }
 
 bool CompilerDispatcherJob::FinalizeCompilingOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kCompiled);
 
-  if (compile_job_->state() == CompilationJob::State::kFailed ||
-      !Compiler::FinalizeCompilationJob(compile_job_.release())) {
-    if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
-    status_ = CompileJobStatus::kFailed;
-    return false;
+  for (auto& job : compile_jobs_) {
+    if (job->state() == CompilationJob::State::kFailed ||
+        !Compiler::FinalizeCompilationJob(job.release())) {
+      if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
+      status_ = CompileJobStatus::kFailed;
+      return false;
+    }
   }
 
   zone_.reset();
   parse_info_.reset();
   compile_info_.reset();
-  compile_job_.reset();
+  compile_jobs_.clear();
   handles_from_parsing_.reset();
 
   status_ = CompileJobStatus::kDone;
   return true;
 }
 
 void CompilerDispatcherJob::ResetOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
 
   parser_.reset();
   unicode_cache_.reset();
   character_stream_.reset();
   parse_info_.reset();
   zone_.reset();
   handles_from_parsing_.reset();
   compile_info_.reset();
-  compile_job_.reset();
+  compile_jobs_.clear();
 
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
 
   status_ = CompileJobStatus::kInitial;
 }
 
 }  // namespace internal
 }  // namespace v8