Allow TurboFan to compile more methods.

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-numbering.h"
 #include "src/bootstrapper.h"
@@ skipping 304 matching lines @@
 
 OptimizedCompileJob::Status OptimizedCompileJob::CreateGraph() {
   DCHECK(info()->IsOptimizing());
   DCHECK(!info()->IsCompilingForDebugging());
 
   // Do not use Crankshaft/TurboFan if we need to be able to set break points.
   if (isolate()->debug()->has_break_points()) {
     return RetryOptimization(kDebuggerHasBreakPoints);
   }
 
-  // Limit the number of times we re-compile a functions with
-  // the optimizing compiler.
+  // 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()->opt_count() > kMaxOptCount) {
     return AbortOptimization(kOptimizedTooManyTimes);
   }
 
-  // Due to an encoding limit on LUnallocated operands in the Lithium
-  // language, we cannot optimize functions with too many formal parameters
-  // or perform on-stack replacement for function with too many
-  // stack-allocated local variables.
-  //
-  // The encoding is as a signed value, with parameters and receiver using
-  // the negative indices and locals the non-negative ones.
-  const int parameter_limit = -LUnallocated::kMinFixedSlotIndex;
-  Scope* scope = info()->scope();
-  if ((scope->num_parameters() + 1) > parameter_limit) {
-    return AbortOptimization(kTooManyParameters);
-  }
-
-  const int locals_limit = LUnallocated::kMaxFixedSlotIndex;
-  if (info()->is_osr() &&
-      scope->num_parameters() + 1 + scope->num_stack_slots() > locals_limit) {
-    return AbortOptimization(kTooManyParametersLocals);
-  }
-
   // Check the whitelist for Crankshaft.
   if (!info()->closure()->PassesFilter(FLAG_hydrogen_filter)) {
     return AbortOptimization(kHydrogenFilter);
   }
 
   // Optimization requires a version of fullcode with deoptimization support.
   // Recompile the unoptimized version of the code if the current version
   // doesn't have deoptimization support already.
   // Otherwise, if we are gathering compilation time and space statistics
   // for hydrogen, gather baseline statistics for a fullcode compilation.
@@ skipping 10 matching lines @@
       isolate()->GetHStatistics()->IncrementFullCodeGen(timer.Elapsed());
     }
   }
 
   DCHECK(info()->shared_info()->has_deoptimization_support());
 
   // Check the enabling conditions for TurboFan.
   if (((FLAG_turbo_asm && info()->shared_info()->asm_function()) ||
        info()->closure()->PassesFilter(FLAG_turbo_filter)) &&
       (FLAG_turbo_osr || !info()->is_osr())) {
+    // Use TurboFan for the compilation.
     if (FLAG_trace_opt) {
       OFStream os(stdout);
       os << "[compiling method " << Brief(*info()->closure())
          << " using TurboFan";
       if (info()->is_osr()) os << " OSR";
       os << "]" << std::endl;
     }
 
     if (info()->shared_info()->asm_function()) {
       info()->MarkAsContextSpecializing();
     } else if (FLAG_turbo_type_feedback) {
       info()->MarkAsTypeFeedbackEnabled();
       info()->EnsureFeedbackVector();
     }
 
     Timer t(this, &time_taken_to_create_graph_);
     compiler::Pipeline pipeline(info());
     pipeline.GenerateCode();
     if (!info()->code().is_null()) {
       info()->dependencies()->Commit(info()->code());
       return SetLastStatus(SUCCEEDED);
     }
   }
 
-  // Do not use Crankshaft if the code is intended to be serialized.
-  if (!isolate()->use_crankshaft()) return SetLastStatus(FAILED);
+  if (!isolate()->use_crankshaft()) {
+    // Crankshaft is entirely disabled.
+    return SetLastStatus(FAILED);
+  }
+
+  Scope* scope = info()->scope();
+  if (LUnallocated::TooManyParameters(scope->num_parameters())) {
+    // Crankshaft would require too many Lithium operands.
+    return AbortOptimization(kTooManyParameters);
+  }
+
+  if (info()->is_osr() &&
+      LUnallocated::TooManyParametersOrStackSlots(scope->num_parameters(),
+                                                  scope->num_stack_slots())) {
+    // Crankshaft would require too many Lithium operands.
+    return AbortOptimization(kTooManyParametersLocals);
+  }
 
   if (scope->HasIllegalRedeclaration()) {
     // Crankshaft cannot handle illegal redeclarations.
     return AbortOptimization(kFunctionWithIllegalRedeclaration);
   }
 
   if (FLAG_trace_opt) {
     OFStream os(stdout);
     os << "[compiling method " << Brief(*info()->closure())
        << " using Crankshaft";
@@ skipping 1127 matching lines @@
 }
 
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate(), zone()).PrintProgram(function()));
 }
 #endif
 } }  // namespace v8::internal