[turbofan] Always inline small functions directly.

src/compiler/js-inlining-heuristic.cc

 // Copyright 2015 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/js-inlining-heuristic.h"
 
 #include "src/compilation-info.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 47 matching lines @@
   // Quick check on the size of the AST to avoid parsing large candidate.
   if (shared->ast_node_count() > FLAG_max_inlined_nodes) {
     return false;
   }
 
   // Avoid inlining across the boundary of asm.js code.
   if (shared->asm_function()) return false;
   return true;
 }
 
+bool IsSmallInlineFunction(Handle<SharedFunctionInfo> shared) {
+  // Don't forcibly inline functions that weren't compiled yet.
+  if (shared->ast_node_count() == 0) return false;
+
+  // Forcibly inline small functions.
+  if (shared->ast_node_count() <= FLAG_max_inlined_nodes_small) return true;
+  return false;
+}
+
 }  // namespace
 
 Reduction JSInliningHeuristic::Reduce(Node* node) {
   if (!IrOpcode::IsInlineeOpcode(node->opcode())) return NoChange();
 
   // Check if we already saw that {node} before, and if so, just skip it.
   if (seen_.find(node->id()) != seen_.end()) return NoChange();
   seen_.insert(node->id());
 
   // Check if the {node} is an appropriate candidate for inlining.
   Node* callee = node->InputAt(0);
   Candidate candidate;
   candidate.node = node;
   candidate.num_functions = CollectFunctions(
       callee, candidate.functions, kMaxCallPolymorphism, candidate.shared_info);
   if (candidate.num_functions == 0) {
     return NoChange();
   } else if (candidate.num_functions > 1 && !FLAG_polymorphic_inlining) {
     TRACE(
         "Not considering call site #%d:%s, because polymorphic inlining "
         "is disabled\n",
         node->id(), node->op()->mnemonic());
     return NoChange();
   }
 
   // Functions marked with %SetForceInlineFlag are immediately inlined.
-  bool can_inline = false, force_inline = true;
+  bool can_inline = false, force_inline = true, small_inline = true;
   for (int i = 0; i < candidate.num_functions; ++i) {
     Handle<SharedFunctionInfo> shared =
         candidate.functions[i].is_null()
             ? candidate.shared_info
             : handle(candidate.functions[i]->shared());
     if (!shared->force_inline()) {
       force_inline = false;
     }
     if (CanInlineFunction(shared)) {
       can_inline = true;
     }
+    if (!IsSmallInlineFunction(shared)) {
+      small_inline = false;
+    }
   }
   if (force_inline) return InlineCandidate(candidate);
   if (!can_inline) return NoChange();
 
   // Stop inlining once the maximum allowed level is reached.
   int level = 0;
   for (Node* frame_state = NodeProperties::GetFrameStateInput(node);
        frame_state->opcode() == IrOpcode::kFrameState;
        frame_state = NodeProperties::GetFrameStateInput(frame_state)) {
     FrameStateInfo const& frame_info = OpParameter<FrameStateInfo>(frame_state);
@@ skipping 31 matching lines @@
   }
 
   // Don't consider a {candidate} whose frequency is below the
   // threshold, i.e. a call site that is only hit once every N
   // invocations of the caller.
   if (candidate.frequency.IsKnown() &&
       candidate.frequency.value() < FLAG_min_inlining_frequency) {
     return NoChange();
   }
 
+  // Forcibly inline small functions here.
+  if (small_inline) {
+    TRACE("Inlining small function(s) at call site #%d:%s\n", node->id(),
+          node->op()->mnemonic());
+    return InlineCandidate(candidate);
+  }
+
   // In the general case we remember the candidate for later.
   candidates_.insert(candidate);
   return NoChange();
 }
 
 void JSInliningHeuristic::Finalize() {
   if (candidates_.empty()) return;  // Nothing to do without candidates.
   if (FLAG_trace_turbo_inlining) PrintCandidates();
 
   // We inline at most one candidate in every iteration of the fixpoint.
@@ skipping 156 matching lines @@
   return jsgraph()->common();
 }
 
 SimplifiedOperatorBuilder* JSInliningHeuristic::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8