[compiler] Unify common code in GetOptimizedCode.

src/compiler.cc

 // 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.
 
 #include "src/compiler.h"
 
 #include <algorithm>
 
 #include "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 681 matching lines @@
 
   // If this is OSR request, OSR must be enabled by Turbofan.
   bool passes_osr_test = FLAG_turbo_osr || !info->is_osr();
 
   return (is_turbofanable_asm ||
           is_unsupported_by_crankshaft_but_turbofanable ||
           passes_turbo_filter) &&
          passes_osr_test;
 }
 
-bool GetOptimizedCodeNow(CompilationInfo* info) {
+bool GetOptimizedCodeNow(OptimizedCompileJob* job) {
+  CompilationInfo* info = job->info();
   Isolate* isolate = info->isolate();
-  CanonicalHandleScope canonical(isolate);
-  TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
-  TRACE_EVENT0("v8", "V8.OptimizeCode");
-
-  bool use_turbofan = UseTurboFan(info);
-  base::SmartPointer<OptimizedCompileJob> job(
-      use_turbofan ? compiler::Pipeline::NewCompilationJob(info)
-                   : new HCompilationJob(info));
 
   // Parsing is not required when optimizing from existing bytecode.
-  if (!use_turbofan || !info->shared_info()->HasBytecodeArray()) {
+  if (!info->is_optimizing_from_bytecode()) {
     if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
-  } else {
-    info->MarkAsOptimizeFromBytecode();
   }
 
   TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
   TRACE_EVENT0("v8", "V8.RecompileSynchronous");
 
   if (job->CreateGraph() != OptimizedCompileJob::SUCCEEDED ||
       job->OptimizeGraph() != OptimizedCompileJob::SUCCEEDED ||
       job->GenerateCode() != OptimizedCompileJob::SUCCEEDED) {
     if (FLAG_trace_opt) {
       PrintF("[aborted optimizing ");
       info->closure()->ShortPrint();
       PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
     }
     return false;
   }
 
   // Success!
   job->RecordOptimizationStats();
   DCHECK(!isolate->has_pending_exception());
   InsertCodeIntoOptimizedCodeMap(info);
   RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info);
   return true;
 }
 
-bool GetOptimizedCodeLater(CompilationInfo* info) {
+bool GetOptimizedCodeLater(OptimizedCompileJob* job) {
+  CompilationInfo* info = job->info();
   Isolate* isolate = info->isolate();
-  CanonicalHandleScope canonical(isolate);
-  TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
-  TRACE_EVENT0("v8", "V8.OptimizeCode");
 
   if (!isolate->optimizing_compile_dispatcher()->IsQueueAvailable()) {
     if (FLAG_trace_concurrent_recompilation) {
       PrintF("  ** Compilation queue full, will retry optimizing ");
       info->closure()->ShortPrint();
       PrintF(" later.\n");
     }
     return false;
   }
 
-  bool use_turbofan = UseTurboFan(info);
-  base::SmartPointer<OptimizedCompileJob> job(
-      use_turbofan ? compiler::Pipeline::NewCompilationJob(info)
-                   : new HCompilationJob(info));
-
   // All handles below this point will be allocated in a deferred handle scope
   // that is detached and handed off to the background thread when we return.
   CompilationHandleScope handle_scope(info);
 
   // Parsing is not required when optimizing from existing bytecode.
-  if (!use_turbofan || !info->shared_info()->HasBytecodeArray()) {
+  if (!info->is_optimizing_from_bytecode()) {
     if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
-  } else {
-    info->MarkAsOptimizeFromBytecode();
   }
 
   // Reopen handles in the new CompilationHandleScope.
   info->ReopenHandlesInNewHandleScope();
   info->parse_info()->ReopenHandlesInNewHandleScope();
 
   TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
   TRACE_EVENT0("v8", "V8.RecompileSynchronous");
 
   if (job->CreateGraph() != OptimizedCompileJob::SUCCEEDED) return false;
-  isolate->optimizing_compile_dispatcher()->QueueForOptimization(job.get());
-  job.Detach();  // The background recompile job owns this now.
+  isolate->optimizing_compile_dispatcher()->QueueForOptimization(job);
 
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Queued ");
     info->closure()->ShortPrint();
     PrintF(" for concurrent optimization.\n");
   }
   return true;
 }
 
 MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
@@ skipping 50 matching lines @@
   }
 
   // Limit the number of times we try to optimize functions.
   const int kMaxOptCount =
       FLAG_deopt_every_n_times == 0 ? FLAG_max_opt_count : 1000;
   if (info->shared_info()->opt_count() > kMaxOptCount) {
     info->AbortOptimization(kOptimizedTooManyTimes);
     return MaybeHandle<Code>();
   }
 
+  CanonicalHandleScope canonical(isolate);
+  TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
+  TRACE_EVENT0("v8", "V8.OptimizeCode");
+
+  bool use_turbofan = UseTurboFan(info.get());
+  base::SmartPointer<OptimizedCompileJob> job(
+      use_turbofan ? compiler::Pipeline::NewCompilationJob(info.get())
+                   : new HCompilationJob(info.get()));
+
+  // TruboFan can optimize directly from existing bytecode.
+  if (use_turbofan && info->shared_info()->HasBytecodeArray()) {
+    info->MarkAsOptimizeFromBytecode();
+  }
+
   if (mode == Compiler::CONCURRENT) {
-    if (GetOptimizedCodeLater(info.get())) {
+    if (GetOptimizedCodeLater(job.get())) {
       info.Detach();  // The background recompile job owns this now.
+      job.Detach();   // The background recompile job owns this now.
       return isolate->builtins()->InOptimizationQueue();
     }
   } else {
     info->set_osr_frame(osr_frame);
-    if (GetOptimizedCodeNow(info.get())) return info->code();
+    if (GetOptimizedCodeNow(job.get())) return info->code();
   }
 
   if (isolate->has_pending_exception()) isolate->clear_pending_exception();
   return MaybeHandle<Code>();
 }
 
 class InterpreterActivationsFinder : public ThreadVisitor {
  public:
   SharedFunctionInfo* shared_;
   bool has_activations_;
@@ skipping 937 matching lines @@
     MaybeHandle<Code> code;
     if (cached.code != nullptr) code = handle(cached.code);
     Handle<Context> native_context(function->context()->native_context());
     SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
                                               literals, BailoutId::None());
   }
 }
 
 }  // namespace internal
 }  // namespace v8