Relax inlining limits for simple leaf functions (second version).

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4628 matching lines @@
   CallKind call_kind = (expr->expression()->AsProperty() == NULL)
       ? CALL_AS_FUNCTION
       : CALL_AS_METHOD;
 
   // Precondition: call is monomorphic and we have found a target with the
   // appropriate arity.
   Handle<JSFunction> caller = info()->closure();
   Handle<JSFunction> target = expr->target();
   Handle<SharedFunctionInfo> target_shared(target->shared());
 
-  // Do a quick check on source code length to avoid parsing large
-  // inlining candidates.
-  if (FLAG_limit_inlining && target->shared()->SourceSize() > kMaxSourceSize) {
-    TraceInline(target, caller, "target text too big");
+  if (!target_shared->is_inlineable()) {
+    TraceInline(target, caller, "target has non-trivial declarations"
+                                " or statements.");
     return false;
   }
 
+  int ast_node_count = target_shared->ast_node_count();
+
+  if (FLAG_limit_inlining) {
+    if (ast_node_count > kMaxInlinedSize) {
+      // Never inline big functions.
+      TraceInline(target, caller, "target AST is too large");
+      return false;
+    }
+
+    if (target->shared()->SourceSize() > kMaxSourceSize) {
+      // Never inline big functions.
+      TraceInline(target, caller, "target text too big");
+      return false;
+    }
+
+    if (inlined_count_ > kMaxInlinedNodesHard) {
+      // Do not inline after the hard limit is reached.
+      TraceInline(target, caller, "cumulative AST node limit reached");
+      return false;
+    }
+
+    if (inlined_count_ > kMaxInlinedNodesSoft) {
+      // Inline only small primitive functions after the soft limit is reached.
+      // See comments of AstNode::IsInlineable for definition of "primitive".
+      if (ast_node_count > kMaxInlinedPrimitiveSize ||
+          !target_shared->is_primitive()) {
+        TraceInline(target, caller, "cumulative AST node limit reached (soft)");
+        return false;
+      }
+    }
+  }
+
   // Target must be inlineable.
   if (!target->IsInlineable()) {
     TraceInline(target, caller, "target not inlineable");
     return false;
   }
 
 #if !defined(V8_TARGET_ARCH_IA32)
   // Target must be able to use caller's context.
   CompilationInfo* outer_info = info();
   if (target->context() != outer_info->closure()->context() ||
@@ skipping 20 matching lines @@
   // Don't inline recursive functions.
   for (FunctionState* state = function_state();
        state != NULL;
        state = state->outer()) {
     if (state->compilation_info()->closure()->shared() == *target_shared) {
       TraceInline(target, caller, "target is recursive");
       return false;
     }
   }
 
-  // We don't want to add more than a certain number of nodes from inlining.
-  if (FLAG_limit_inlining && inlined_count_ > kMaxInlinedNodes) {
-    TraceInline(target, caller, "cumulative AST node limit reached");
-    return false;
-  }
-
-  int count_before = AstNode::Count();
-
   // Parse and allocate variables.
   CompilationInfo target_info(target);
   if (!ParserApi::Parse(&target_info) ||
       !Scope::Analyze(&target_info)) {
     if (target_info.isolate()->has_pending_exception()) {
       // Parse or scope error, never optimize this function.
       SetStackOverflow();
       target_shared->DisableOptimization(*target);
     }
     TraceInline(target, caller, "parse failure");
     return false;
   }
 
   if (target_info.scope()->num_heap_slots() > 0) {
     TraceInline(target, caller, "target has context-allocated variables");
     return false;
   }
+
   FunctionLiteral* function = target_info.function();
 
-  // Count the number of AST nodes added by inlining this call.
-  int nodes_added = AstNode::Count() - count_before;
-  if (FLAG_limit_inlining && nodes_added > kMaxInlinedSize) {
-    TraceInline(target, caller, "target AST is too large");
-    return false;
-  }
-
   // Don't inline functions that uses the arguments object or that
   // have a mismatching number of parameters.
   int arity = expr->arguments()->length();
   if (function->scope()->arguments() != NULL ||
       arity != target_shared->formal_parameter_count()) {
     TraceInline(target, caller, "target requires special argument handling");
     return false;
   }
 
-  // All declarations must be inlineable.
-  ZoneList<Declaration*>* decls = target_info.scope()->declarations();
-  int decl_count = decls->length();
-  for (int i = 0; i < decl_count; ++i) {
-    if (!decls->at(i)->IsInlineable()) {
-      TraceInline(target, caller, "target has non-trivial declaration");
-      return false;
-    }
-  }
-  // All statements in the body must be inlineable.
-  for (int i = 0, count = function->body()->length(); i < count; ++i) {
-    if (!function->body()->at(i)->IsInlineable()) {
-      TraceInline(target, caller, "target contains unsupported syntax");
-      return false;
-    }
-  }
-
   // Generate the deoptimization data for the unoptimized version of
   // the target function if we don't already have it.
   if (!target_shared->has_deoptimization_support()) {
     // Note that we compile here using the same AST that we will use for
     // generating the optimized inline code.
     target_info.EnableDeoptimizationSupport();
     if (!FullCodeGenerator::MakeCode(&target_info)) {
       TraceInline(target, caller, "could not generate deoptimization info");
       return false;
     }
@@ skipping 56 matching lines @@
     // Bail out if the inline function did, as we cannot residualize a call
     // instead.
     TraceInline(target, caller, "inline graph construction failed");
     target_shared->DisableOptimization(*target);
     inline_bailout_ = true;
     delete target_state;
     return true;
   }
 
   // Update inlined nodes count.
-  inlined_count_ += nodes_added;
+  inlined_count_ += ast_node_count;
 
   TraceInline(target, caller, NULL);
 
   if (current_block() != NULL) {
     // Add a return of undefined if control can fall off the body.  In a
     // test context, undefined is false.
     if (inlined_test_context() == NULL) {
       ASSERT(function_return() != NULL);
       ASSERT(call_context()->IsEffect() || call_context()->IsValue());
       if (call_context()->IsEffect()) {
@@ skipping 2309 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal