[compiler] Prevent unnecessary parsing with interpreter.

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 690 matching lines @@
           passes_turbo_filter) &&
          passes_osr_test;
 }
 
 bool GetOptimizedCodeNow(CompilationInfo* info) {
   Isolate* isolate = info->isolate();
   CanonicalHandleScope canonical(isolate);
   TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
   TRACE_EVENT0("v8", "V8.OptimizeCode");
 
-  if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
+  bool use_turbofan = UseTurboFan(info);
+  OptimizedCompileJob* job = use_turbofan
+                                 ? compiler::Pipeline::NewCompilationJob(info)
+                                 : new (info->zone()) HCompilationJob(info);
+
+  // Parsing is not required when optimizing from existing bytecode.
+  if (!use_turbofan || !info->shared_info()->HasBytecodeArray()) {
+    if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
+  } else {
+    info->MarkAsOptimizeFromBytecode();
+  }
 
   TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
   TRACE_EVENT0("v8", "V8.RecompileSynchronous");
 
-  OptimizedCompileJob* job = UseTurboFan(info)
-                                 ? compiler::Pipeline::NewCompilationJob(info)
-                                 : new (info->zone()) HCompilationJob(info);
   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;
   }
@@ skipping 15 matching lines @@
 
   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);
+  OptimizedCompileJob* job = use_turbofan
+                                 ? compiler::Pipeline::NewCompilationJob(info)
+                                 : new (info->zone()) 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);
-  if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
+
+  // Parsing is not required when optimizing from existing bytecode.
+  if (!use_turbofan || !info->shared_info()->HasBytecodeArray()) {
+    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");
 
-  OptimizedCompileJob* job = UseTurboFan(info)
-                                 ? compiler::Pipeline::NewCompilationJob(info)
-                                 : new (info->zone()) HCompilationJob(info);
-  OptimizedCompileJob::Status status = job->CreateGraph();
-  if (status != OptimizedCompileJob::SUCCEEDED) return false;
+  if (job->CreateGraph() != OptimizedCompileJob::SUCCEEDED) return false;
   isolate->optimizing_compile_dispatcher()->QueueForOptimization(job);
 
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Queued ");
     info->closure()->ShortPrint();
     if (info->is_osr()) {
       PrintF(" for concurrent OSR at %d.\n", info->osr_ast_id().ToInt());
     } else {
       PrintF(" for concurrent optimization.\n");
     }
@@ skipping 886 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