[Compiler] Add compile to CompilerDispatcherJob.

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/global-handles.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 49 matching lines @@
   } else {
     source = String::Flatten(source);
     // Have to globalize the reference here, so it survives between function
     // calls.
     source_ = Handle<String>::cast(isolate_->global_handles()->Create(*source));
     character_stream_.reset(new GenericStringUtf16CharacterStream(
         source_, shared->start_position(), shared->end_position()));
   }
   parse_info_.reset(new ParseInfo(zone_.get()));
   parse_info_->set_isolate(isolate_);
+  parse_info_->set_shared_info(shared);
   parse_info_->set_character_stream(character_stream_.get());
   parse_info_->set_lazy();
   parse_info_->set_hash_seed(isolate_->heap()->HashSeed());
   parse_info_->set_is_named_expression(shared->is_named_expression());
   parse_info_->set_calls_eval(shared->scope_info()->CallsEval());
   parse_info_->set_compiler_hints(shared->compiler_hints());
   parse_info_->set_start_position(shared->start_position());
   parse_info_->set_end_position(shared->end_position());
   parse_info_->set_unicode_cache(unicode_cache_.get());
   parse_info_->set_language_mode(shared->language_mode());
@@ skipping 47 matching lines @@
     source_ = Handle<String>::null();
   }
 
   if (parse_info_->literal() == nullptr) {
     status_ = CompileJobStatus::kFailed;
     return;
   }
 
   InternalizeParsingResult();
 
+  status_ = CompileJobStatus::kReadyToAnalyse;
+}
+
+void CompilerDispatcherJob::PrepareToCompileOnMainThread() {
+  DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
+  DCHECK(status() == CompileJobStatus::kReadyToAnalyse);
+
+  compile_info_.reset(new CompilationInfo(parse_info_.get(), function_));
+
+  // Create a canonical handle scope before ast numbering if compiling bytecode.
+  // This is required for off-thread bytecode generation.
+  std::unique_ptr<CanonicalHandleScope> canonical;
+  if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate_));
+
+  if (!Compiler::Analyze(parse_info_.get())) {
+    status_ = CompileJobStatus::kFailed;
+    return;
+  }
+  compile_job_.reset(
+      Compiler::PrepareUnoptimizedCompilationJob(compile_info_.get()));
+  if (!compile_job_.get()) {
+    status_ = CompileJobStatus::kFailed;
+    return;
+  }
+
   status_ = CompileJobStatus::kReadyToCompile;
 }
 
+void CompilerDispatcherJob::Compile() {
+  DCHECK(status() == CompileJobStatus::kReadyToCompile);
+  DisallowHeapAllocation no_allocation;
+  DisallowHandleAllocation no_handles;
+  DisallowHandleDereference no_deref;
+
+  uintptr_t stack_limit =
+      reinterpret_cast<uintptr_t>(&stack_limit) - max_stack_size_ * KB;
+  compile_job_->set_stack_limit(stack_limit);
+
+  if (compile_job_->ExecuteJob() != CompilationJob::SUCCEEDED) {
+    status_ = CompileJobStatus::kFailed;
+    return;
+  }
+
+  status_ = CompileJobStatus::kCompiled;
+}
+
+void CompilerDispatcherJob::FinalizeCompilingOnMainThread() {
+  DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
+  DCHECK(status() == CompileJobStatus::kCompiled);
+
+  if (!Compiler::FinalizeCompilationJob(compile_job_.release())) {
+    status_ = CompileJobStatus::kFailed;
+    return;
+  }
+
+  status_ = CompileJobStatus::kDone;
+}
+
 void CompilerDispatcherJob::ReportErrorsOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kFailed);
 
   // Internalizing the parsing result will throw the error.
   InternalizeParsingResult();
 
   status_ = CompileJobStatus::kDone;
 }
 
 void CompilerDispatcherJob::ResetOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
 
   parser_.reset();
   unicode_cache_.reset();
   character_stream_.reset();
   parse_info_.reset();
+  compile_info_.reset();
   zone_.reset();
 
   if (!source_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(source_).location());
     source_ = Handle<String>::null();
   }
 
   status_ = CompileJobStatus::kInitial;
 }
 
 void CompilerDispatcherJob::InternalizeParsingResult() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status() == CompileJobStatus::kParsed ||
          status() == CompileJobStatus::kFailed);
 
-  HandleScope scope(isolate_);

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

I've removed this HandleScope because the handles created during parser
internalization need to be live for compilation.

-
   // Create a canonical handle scope before internalizing parsed values if
   // compiling bytecode. This is required for off-thread bytecode generation.
   std::unique_ptr<CanonicalHandleScope> canonical;
   if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate_));
 
   Handle<SharedFunctionInfo> shared(function_->shared(), isolate_);
   Handle<Script> script(Script::cast(shared->script()), isolate_);
 
   parse_info_->set_script(script);
   parse_info_->set_context(handle(function_->context(), isolate_));
 
   // Do the parsing tasks which need to be done on the main thread. This will
   // also handle parse errors.
   parser_->Internalize(isolate_, script, parse_info_->literal() == nullptr);
   parser_->HandleSourceURLComments(isolate_, script);
 
   parse_info_->set_character_stream(nullptr);
   parse_info_->set_unicode_cache(nullptr);
   parser_.reset();
   unicode_cache_.reset();
   character_stream_.reset();
 }
 
 }  // namespace internal
 }  // namespace v8