[Compiler] Skip Ignition for asm.js code.

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 921 matching lines @@
 
   // Install compilation result on the shared function info
   InstallSharedCompilationResult(&info, shared);
 
   // Record the function compilation event.
   RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, &info);
 
   return info.code();
 }
 
+bool ShouldOptimizeForAsm(Isolate* isolate, Handle<JSFunction> function) {
+  // If the debugger is active, do not compile with turbofan unless we can
+  // deopt from turbofan code.
+  return FLAG_turbo_asm && function->shared()->asm_function() &&
+         (FLAG_turbo_asm_deoptimization || !isolate->debug()->is_active());
+}
+
 MaybeHandle<Code> GetLazyCode(Handle<JSFunction> function) {
   Isolate* isolate = function->GetIsolate();
   DCHECK(!isolate->has_pending_exception());
   DCHECK(!function->is_compiled());
   TimerEventScope<TimerEventCompileCode> compile_timer(isolate);
   TRACE_EVENT0("v8", "V8.CompileCode");
   AggregatedHistogramTimerScope timer(isolate->counters()->compile_lazy());
 
   if (FLAG_turbo_cache_shared_code) {
     Handle<Code> cached_code;
     if (GetCodeFromOptimizedCodeMap(function, BailoutId::None())
             .ToHandle(&cached_code)) {
       if (FLAG_trace_opt) {
         PrintF("[found optimized code for ");
         function->ShortPrint();
         PrintF(" during unoptimized compile]\n");
       }
       DCHECK(function->shared()->is_compiled());
       return cached_code;
     }
   }
 
   if (function->shared()->is_compiled()) {
     return Handle<Code>(function->shared()->code());
   }
 
+  if (FLAG_always_opt || ShouldOptimizeForAsm(isolate, function)) {
+    Handle<Code> opt_code;
+    if (GetOptimizedCode(function, Compiler::NOT_CONCURRENT)
+            .ToHandle(&opt_code)) {
+      DCHECK(function->shared()->is_compiled());
+      return opt_code;
+    }
+  }
+
   Zone zone(isolate->allocator());
   ParseInfo parse_info(&zone, function);
   CompilationInfo info(&parse_info, function);
   Handle<Code> result;
   ASSIGN_RETURN_ON_EXCEPTION(isolate, result, GetUnoptimizedCode(&info), Code);
 
-  if (FLAG_always_opt) {
-    Handle<Code> opt_code;
-    if (GetOptimizedCode(function, Compiler::NOT_CONCURRENT)
-            .ToHandle(&opt_code)) {
-      result = opt_code;
-    }
-  }
-
   return result;
 }
 
+bool GetEagerCode(CompilationInfo* info) {

[rmcilroy, 2016/05/20 10:04:16]

I factored this code out of NewSharedFunctionInfoForLiteral when I was thinking
about doing this a different way. I ended up not needing to do this, and the
code here is practically the same as was in NewSharedFunctionInfoForLiteral, but
I think it is clearer as a seperate function like this. WDYT? Happy to remove
this part of the change if you don't like it.

+  Isolate* isolate = info->isolate();
+  DCHECK(!isolate->has_pending_exception());
+  DCHECK(info->code().is_null());
+  DCHECK_NOT_NULL(info->literal());
+  DCHECK_NOT_NULL(info->scope());
+  TimerEventScope<TimerEventCompileCode> compile_timer(isolate);
+  TRACE_EVENT0("v8", "V8.CompileCode");
+
+  if (!Renumber(info->parse_info()) || !GenerateUnoptimizedCode(info)) {
+    return false;
+  }
+
+  // Code generation will ensure that the feedback vector is present and
+  // appropriately sized.
+  DCHECK(!info->code().is_null());
+
+  if (info->literal()->should_eager_compile() &&
+      info->literal()->should_be_used_once_hint()) {
+    info->code()->MarkToBeExecutedOnce(isolate);
+  }
+
+  // Update the shared function info with the scope info.
+  InstallSharedScopeInfo(info, info->shared_info());
+  // Install compilation result on the shared function info.
+  InstallSharedCompilationResult(info, info->shared_info());
+
+  return true;
+}
 
 Handle<SharedFunctionInfo> NewSharedFunctionInfoForLiteral(
     Isolate* isolate, FunctionLiteral* literal, Handle<Script> script) {
   Handle<Code> code = isolate->builtins()->CompileLazy();
   Handle<ScopeInfo> scope_info = handle(ScopeInfo::Empty(isolate));
   Handle<SharedFunctionInfo> result = isolate->factory()->NewSharedFunctionInfo(
       literal->name(), literal->materialized_literal_count(), literal->kind(),
       code, scope_info);
   SharedFunctionInfo::InitFromFunctionLiteral(result, literal);
   SharedFunctionInfo::SetScript(result, script);
@@ skipping 642 matching lines @@
   bool lazy = FLAG_lazy && allow_lazy && !literal->should_eager_compile();
 
   // Consider compiling eagerly when targeting the code cache.
   lazy &= !(FLAG_serialize_eager && info.will_serialize());
 
   // Consider compiling eagerly when compiling bytecode for Ignition.
   lazy &=
       !(FLAG_ignition && FLAG_ignition_eager && !isolate->serializer_enabled());
 
   // Generate code
-  TimerEventScope<TimerEventCompileCode> timer(isolate);
-  TRACE_EVENT0("v8", "V8.CompileCode");
   if (lazy) {
     info.SetCode(isolate->builtins()->CompileLazy());
-  } else if (Renumber(info.parse_info()) && GenerateUnoptimizedCode(&info)) {
-    // Code generation will ensure that the feedback vector is present and
-    // appropriately sized.
-    DCHECK(!info.code().is_null());
-    if (literal->should_eager_compile() &&
-        literal->should_be_used_once_hint()) {
-      info.code()->MarkToBeExecutedOnce(isolate);
-    }
-    // Update the shared function info with the scope info.
-    InstallSharedScopeInfo(&info, result);
-    // Install compilation result on the shared function info.
-    InstallSharedCompilationResult(&info, result);
-  } else {
+  } else if (!GetEagerCode(&info)) {
     return Handle<SharedFunctionInfo>::null();
   }
 
   if (maybe_existing.is_null()) {
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info);
   }
 
   return result;
 }
 
@@ skipping 83 matching lines @@
   if (FLAG_trace_opt) {
     PrintF("[aborted optimizing ");
     info->closure()->ShortPrint();
     PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
   }
   info->closure()->ReplaceCode(shared->code());
 }
 
 void Compiler::PostInstantiation(Handle<JSFunction> function,
                                  PretenureFlag pretenure) {
+  Isolate* isolate = function->GetIsolate();
   Handle<SharedFunctionInfo> shared(function->shared());
 
-  if (FLAG_always_opt && shared->allows_lazy_compilation()) {
+  if ((FLAG_always_opt || ShouldOptimizeForAsm(isolate, function)) &&
+      shared->allows_lazy_compilation()) {
     function->MarkForOptimization();
   }
 
   CodeAndLiterals cached = shared->SearchOptimizedCodeMap(
       function->context()->native_context(), BailoutId::None());
   if (cached.code != nullptr) {
     // Caching of optimized code enabled and optimized code found.
     DCHECK(!cached.code->marked_for_deoptimization());
     DCHECK(function->shared()->is_compiled());
     function->ReplaceCode(cached.code);
   }
 
   if (cached.literals != nullptr) {
     function->set_literals(cached.literals);
   } else {
-    Isolate* isolate = function->GetIsolate();
     int number_of_literals = shared->num_literals();
     Handle<LiteralsArray> literals =
         LiteralsArray::New(isolate, handle(shared->feedback_vector()),
                            number_of_literals, pretenure);
     function->set_literals(*literals);
 
     // Cache context-specific literals.
     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