[compiler] Don't canonicalize handles in Crankshaft.

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 <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 680 matching lines @@
   }
 
   // Success!
   job->RecordOptimizationStats();
   DCHECK(!isolate->has_pending_exception());
   InsertCodeIntoOptimizedCodeMap(info);
   RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);
   return true;
 }
 
-bool GetOptimizedCodeLater(CompilationJob* job) {
+bool GetOptimizedCodeLater(CompilationJob* job, bool use_turbofan) {
   CompilationInfo* info = job->info();
   Isolate* isolate = info->isolate();
 
   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;
   }
 
   if (isolate->heap()->HighMemoryPressure()) {
     if (FLAG_trace_concurrent_recompilation) {
       PrintF("  ** High memory pressure, will retry optimizing ");
       info->closure()->ShortPrint();
       PrintF(" later.\n");
     }
     return false;
   }
 
   // All handles below this point will be canonicalized and allocated in a
   // deferred handle scope that is detached and handed off to the background
   // thread when we return.
   CompilationHandleScope handle_scope(info);

[Michael Starzinger, 2016/08/25 11:44:20]

Would it be possible to hoist both, the CompilationHandleScope as well as the
CannonicalHandleScope out into the caller. There the usr_turbofan predicate us
available without passing it around magically. Also it would allow us to see
that GetOptimizedCodeNow is in sync.

-  CanonicalHandleScope canonical(isolate);
+  std::unique_ptr<CanonicalHandleScope> canonical;
+  if (use_turbofan) canonical.reset(new CanonicalHandleScope(info->isolate()));
 
   // Parsing is not required when optimizing from existing bytecode.
   if (!info->is_optimizing_from_bytecode()) {
     if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
     EnsureFeedbackMetadata(info);
   }
 
   JSFunction::EnsureLiterals(info->closure());
 
   // Reopen handles in the new CompilationHandleScope.
@@ skipping 95 matching lines @@
 
   if (IsEvalToplevel(shared)) {
     parse_info->set_eval();
     if (function->context()->IsNativeContext()) parse_info->set_global();
     parse_info->set_toplevel();
     parse_info->set_allow_lazy_parsing(false);
     parse_info->set_lazy(false);
   }
 
   if (mode == Compiler::CONCURRENT) {
-    if (GetOptimizedCodeLater(job.get())) {
+    if (GetOptimizedCodeLater(job.get(), use_turbofan)) {
       job.release();  // The background recompile job owns this now.
       return isolate->builtins()->InOptimizationQueue();
     }
   } else {
     if (GetOptimizedCodeNow(job.get())) return info->code();
   }
 
   if (isolate->has_pending_exception()) isolate->clear_pending_exception();
   return MaybeHandle<Code>();
 }
@@ skipping 1131 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8